Add files using upload-large-folder tool

platform/dbops/binaries/weaviate-src/test/modules/generative-aws/setup_test.go

@@ -0,0 +1,72 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeAWS_SingleNode(t *testing.T) {
+	accessKey := os.Getenv("AWS_ACCESS_KEY")
+	if accessKey == "" {
+		accessKey = os.Getenv("AWS_ACCESS_KEY_ID")
+		if accessKey == "" {
+			t.Skip("skipping, AWS_ACCESS_KEY environment variable not present")
+		}
+	}
+	secretKey := os.Getenv("AWS_SECRET_KEY")
+	if secretKey == "" {
+		secretKey = os.Getenv("AWS_SECRET_ACCESS_KEY")
+		if secretKey == "" {
+			t.Skip("skipping, AWS_SECRET_KEY environment variable not present")
+		}
+	}
+	sessionToken := os.Getenv("AWS_SESSION_TOKEN")
+	if sessionToken == "" {
+		t.Skip("skipping, AWS_SESSION_TOKEN environment variable not present")
+	}
+	region := os.Getenv("AWS_REGION")
+	if region == "" {
+		t.Skip("skipping, AWS_REGION environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, accessKey, secretKey, sessionToken)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpointREST := compose.GetWeaviate().URI()
+	endpointGRPC := compose.GetWeaviate().GrpcURI()
+
+	t.Run("tests", testGenerativeAWS(endpointREST, endpointGRPC, region))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, accessKey, secretKey, sessionToken string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(accessKey, secretKey, sessionToken).
+		WithWeaviateWithGRPC().
+		WithWeaviateEnv("MODULES_CLIENT_TIMEOUT", "120s").
+		Start(ctx)
+	return
+}
+
+func composeModules(accessKey, secretKey, sessionToken string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecAWS(accessKey, secretKey, sessionToken).
+		WithGenerativeAWS(accessKey, secretKey, sessionToken)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-cohere/generative_cohere_test.go

@@ -0,0 +1,134 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeCohere(rest, grpc string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(rest)
+		helper.SetupGRPCClient(t, grpc)
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-transformers": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name               string
+			generativeModel    string
+			absentModuleConfig bool
+		}{
+			{
+				name:            "command-r-plus",
+				generativeModel: "command-r-plus",
+			},
+			{
+				name:            "command-r",
+				generativeModel: "command-r",
+			},
+			{
+				name:               "absent module config",
+				generativeModel:    "command-r",
+				absentModuleConfig: true,
+			},
+		}
+		for idx, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				if tt.absentModuleConfig {
+					t.Log("skipping adding module config configuration to class")
+				} else {
+					class.ModuleConfig = map[string]interface{}{
+						"generative-cohere": map[string]interface{}{
+							"model": tt.generativeModel,
+						},
+					}
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					planets.InsertObjects(t, class.Class)
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, planet := range data {
+						t.Run(planet.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+							require.IsType(t, []float32{}, obj.Vectors["description"])
+							assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+						})
+					}
+				})
+				// generative task
+				t.Run("create a tweet", func(t *testing.T) {
+					planets.CreateTweetTest(t, class.Class)
+				})
+				t.Run("create a tweet with params", func(t *testing.T) {
+					params := "cohere:{temperature:0.9 k:400}"
+					if tt.absentModuleConfig {
+						params = fmt.Sprintf("cohere:{temperature:0.9 k:400 model:\"%s\" baseURL:\"https://api.cohere.ai\"}", tt.generativeModel)
+					}
+					planets.CreateTweetTestWithParams(t, class.Class, params)
+				})
+				t.Run("create a tweet using grpc", func(t *testing.T) {
+					planets.CreateTweetTestGRPC(t, class.Class)
+				})
+				t.Run("create a tweet with params using grpc", func(t *testing.T) {
+					cohere := &pb.GenerativeCohere{
+						MaxTokens:        grpchelper.ToPtr(int64(90)),
+						Model:            grpchelper.ToPtr(tt.generativeModel),
+						Temperature:      grpchelper.ToPtr(0.9),
+						K:                grpchelper.ToPtr(int64(90)),
+						P:                grpchelper.ToPtr(0.9),
+						StopSequences:    &pb.TextArray{Values: []string{"stop"}},
+						FrequencyPenalty: grpchelper.ToPtr(0.9),
+					}
+					if tt.absentModuleConfig {
+						cohere.BaseUrl = grpchelper.ToPtr("https://api.cohere.ai")
+					}
+					planets.CreateTweetTestWithParamsGRPC(t, class.Class, &pb.GenerativeProvider{
+						ReturnMetadata: true,
+						Kind:           &pb.GenerativeProvider_Cohere{Cohere: cohere},
+					})
+				})
+			})
+			if idx+1 < len(tests) {
+				time.Sleep(60 * time.Second) // sleep to avoid rate limit on cohere api
+			}
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-cohere/setup_test.go

@@ -0,0 +1,53 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeCohere_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("COHERE_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, COHERE_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpointREST := compose.GetWeaviate().URI()
+	endpointGRPC := compose.GetWeaviate().GrpcURI()
+
+	t.Run("tests", testGenerativeCohere(endpointREST, endpointGRPC))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey).
+		WithWeaviateWithGRPC().
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecTransformers().
+		WithGenerativeCohere(apiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-friendliai/generative_friendliai_test.go

@@ -0,0 +1,94 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package generative_friendliai_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeFriendliAI(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-transformers": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name            string
+			generativeModel string
+			headerURL       string
+		}{
+			{
+				name:            "mixtral-8x7b-instruct-v0-1",
+				generativeModel: "mixtral-8x7b-instruct-v0-1",
+			},
+			{
+				name:            "meta-llama-3.1-8b-instruct",
+				generativeModel: "meta-llama-3.1-8b-instruct",
+			},
+			{
+				name:            "meta-llama-3.1-70b-instruct",
+				generativeModel: "meta-llama-3.1-70b-instruct",
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				class.ModuleConfig = map[string]interface{}{
+					"generative-friendliai": map[string]interface{}{
+						"model":              tt.generativeModel,
+						"X-Friendli-Baseurl": tt.headerURL,
+					},
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					planets.InsertObjects(t, class.Class)
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, planet := range data {
+						t.Run(planet.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+							require.IsType(t, []float32{}, obj.Vectors["description"])
+							assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+						})
+					}
+				})
+				// generative task
+				t.Run("create a tweet", func(t *testing.T) {
+					planets.CreateTweetTest(t, class.Class)
+				})
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-friendliai/setup_test.go

@@ -0,0 +1,52 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package generative_friendliai_tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeFriendliAI_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("FRIENDLI_TOKEN")
+	if apiKey == "" {
+		t.Skip("skipping, FRIENDLI_TOKEN environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("tests", testGenerativeFriendliAI(endpoint))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey).
+		WithWeaviate().
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecTransformers().
+		WithGenerativeFriendliAI(apiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-google/generative_google_test.go

@@ -0,0 +1,210 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeGoogle(rest, grpc, gcpProject, generativeGoogle string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(rest)
+		helper.SetupGRPCClient(t, grpc)
+		// Define path to test/helper/sample-schema/planets/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/planets/data"
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-google": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+						"projectId":          gcpProject,
+						"modelId":            "text-embedding-005",
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name               string
+			generativeModel    string
+			frequencyPenalty   *float64
+			presencePenalty    *float64
+			absentModuleConfig bool
+			withImages         bool
+		}{
+			{
+				name:             "gemini-2.0-flash-lite-001",
+				generativeModel:  "gemini-2.0-flash-lite-001",
+				frequencyPenalty: grpchelper.ToPtr(0.5),
+				presencePenalty:  grpchelper.ToPtr(0.5),
+			},
+			{
+				name:             "gemini-2.0-flash-001",
+				generativeModel:  "gemini-2.0-flash-001",
+				frequencyPenalty: grpchelper.ToPtr(0.5),
+				presencePenalty:  grpchelper.ToPtr(0.5),
+			},
+			{
+				name:               "absent module config",
+				generativeModel:    "gemini-2.0-flash-lite-001",
+				absentModuleConfig: true,
+			},
+			{
+				name:            "gemini-2.0-flash-001",
+				generativeModel: "gemini-2.0-flash-001",
+				withImages:      true,
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				if tt.absentModuleConfig {
+					t.Log("skipping adding module config configuration to class")
+				} else {
+					class.ModuleConfig = map[string]interface{}{
+						generativeGoogle: map[string]interface{}{
+							"projectId": gcpProject,
+							"modelId":   tt.generativeModel,
+						},
+					}
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					if tt.withImages {
+						planets.InsertObjectsWithImages(t, class.Class, dataFolderPath)
+					} else {
+						planets.InsertObjects(t, class.Class)
+					}
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, company := range data {
+						t.Run(company.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, company.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+							require.IsType(t, []float32{}, obj.Vectors["description"])
+							assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+						})
+					}
+				})
+				// generative task
+				if tt.absentModuleConfig {
+					t.Log("skipping create tweet tests with default values as e2e tests rely on specific GCP settings")
+				} else {
+					t.Run("create a tweet", func(t *testing.T) {
+						planets.CreateTweetTest(t, class.Class)
+					})
+					t.Run("create a tweet using grpc", func(t *testing.T) {
+						planets.CreateTweetTestGRPC(t, class.Class)
+					})
+				}
+				t.Run("create a tweet with params", func(t *testing.T) {
+					params := "google:{topP:0.1 topK:40}"
+					if tt.absentModuleConfig {
+						params = fmt.Sprintf("google:{topP:0.1 topK:40 projectId:%q model:%q}", gcpProject, tt.generativeModel)
+					}
+					planets.CreateTweetTestWithParams(t, class.Class, params)
+				})
+
+				params := func() *pb.GenerativeGoogle {
+					params := &pb.GenerativeGoogle{
+						MaxTokens:        grpchelper.ToPtr(int64(256)),
+						Model:            grpchelper.ToPtr(tt.generativeModel),
+						Temperature:      grpchelper.ToPtr(0.5),
+						TopK:             grpchelper.ToPtr(int64(40)),
+						TopP:             grpchelper.ToPtr(0.1),
+						FrequencyPenalty: tt.frequencyPenalty,
+						PresencePenalty:  tt.presencePenalty,
+					}
+					if tt.absentModuleConfig {
+						params.ProjectId = &gcpProject
+					}
+					return params
+				}
+
+				t.Run("create a tweet with params using grpc", func(t *testing.T) {
+					planets.CreateTweetTestWithParamsGRPC(t, class.Class, &pb.GenerativeProvider{
+						ReturnMetadata: true,
+						Kind:           &pb.GenerativeProvider_Google{Google: params()},
+					})
+				})
+				if tt.withImages {
+					t.Run("image prompt", func(t *testing.T) {
+						t.Run("graphql", func(t *testing.T) {
+							prompt := "Caption image"
+							params := "google:{imageProperties:\"image\"}"
+							planets.CreatePromptTestWithParams(t, class.Class, prompt, params)
+						})
+
+						singlePrompt := "Give a short answer: What's on the image?"
+						groupPrompt := "Give a short answer: What are on the following images?"
+
+						t.Run("grpc server stored images", func(t *testing.T) {
+							params := params()
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Google{Google: params},
+							})
+						})
+
+						t.Run("grpc user provided images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Google{Google: params},
+							})
+						})
+
+						t.Run("grpc mixed images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Google{Google: params},
+							})
+						})
+					})
+				}
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-google/setup_test.go

@@ -0,0 +1,59 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeGoogle_VertexAI_SingleNode(t *testing.T) {
+	gcpProject := os.Getenv("GCP_PROJECT")
+	if gcpProject == "" {
+		t.Skip("skipping, GCP_PROJECT environment variable not present")
+	}
+	googleApiKey := os.Getenv("GOOGLE_APIKEY")
+	if googleApiKey == "" {
+		t.Skip("skipping, GOOGLE_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, googleApiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpointREST := compose.GetWeaviate().URI()
+	endpointGRPC := compose.GetWeaviate().GrpcURI()
+
+	t.Run("generative-google", testGenerativeGoogle(endpointREST, endpointGRPC, gcpProject, "generative-google"))
+	t.Run("generative-palm", testGenerativeGoogle(endpointREST, endpointGRPC, gcpProject, "generative-palm"))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, googleApiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(googleApiKey).
+		WithWeaviateWithGRPC().
+		WithWeaviateEnv("MODULES_CLIENT_TIMEOUT", "120s").
+		Start(ctx)
+	return
+}
+
+func composeModules(googleApiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecGoogle(googleApiKey).
+		WithGenerativeGoogle(googleApiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-nvidia/generative_nvidia_test.go

@@ -0,0 +1,121 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeNvidia(rest, grpc string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(rest)
+		helper.SetupGRPCClient(t, grpc)
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-transformers": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name               string
+			generativeModel    string
+			absentModuleConfig bool
+			withImages         bool
+		}{
+			{
+				name:            "meta/llama-3.2-1b-instruct",
+				generativeModel: "meta/llama-3.2-1b-instruct",
+			},
+			{
+				name:               "absent module config",
+				generativeModel:    "microsoft/phi-3.5-mini-instruct",
+				absentModuleConfig: true,
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				if tt.absentModuleConfig {
+					t.Log("skipping adding module config configuration to class")
+				} else {
+					class.ModuleConfig = map[string]interface{}{
+						"generative-nvidia": map[string]interface{}{
+							"model": tt.generativeModel,
+						},
+					}
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					planets.InsertObjects(t, class.Class)
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, planet := range data {
+						t.Run(planet.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+						})
+					}
+				})
+				// generative task
+				t.Run("create a tweet", func(t *testing.T) {
+					planets.CreateTweetTest(t, class.Class)
+				})
+				t.Run("create a tweet with params", func(t *testing.T) {
+					params := "nvidia:{temperature:0.1}"
+					if tt.absentModuleConfig {
+						params = fmt.Sprintf("nvidia:{temperature:0.1 model:\"%s\" baseURL:\"https://integrate.api.nvidia.com\"}", tt.generativeModel)
+					}
+					planets.CreateTweetTestWithParams(t, class.Class, params)
+				})
+				t.Run("create a tweet using grpc", func(t *testing.T) {
+					planets.CreateTweetTestGRPC(t, class.Class)
+				})
+				t.Run("create a tweet with params using grpc", func(t *testing.T) {
+					nvidiaParams := &pb.GenerativeNvidia{
+						Model:       grpchelper.ToPtr(tt.generativeModel),
+						MaxTokens:   grpchelper.ToPtr(int64(1024)),
+						Temperature: grpchelper.ToPtr(0.2),
+						TopP:        grpchelper.ToPtr(0.7),
+					}
+					if tt.absentModuleConfig {
+						nvidiaParams.BaseUrl = grpchelper.ToPtr("https://integrate.api.nvidia.com")
+					}
+					params := &pb.GenerativeProvider_Nvidia{
+						Nvidia: nvidiaParams,
+					}
+					planets.CreateTweetTestWithParamsGRPC(t, class.Class, &pb.GenerativeProvider{ReturnMetadata: true, Kind: params})
+				})
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-nvidia/setup_test.go

@@ -0,0 +1,53 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeNvidia_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("NVIDIA_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, NVIDIA_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpointREST := compose.GetWeaviate().URI()
+	endpointGRPC := compose.GetWeaviate().GrpcURI()
+
+	t.Run("tests", testGenerativeNvidia(endpointREST, endpointGRPC))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey).
+		WithWeaviateWithGRPC().
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecTransformers().
+		WithGenerativeNvidia(apiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-ollama/generative_ollama_test.go

@@ -0,0 +1,111 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeOllama(rest, grpc, ollamaApiEndpoint string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(rest)
+		helper.SetupGRPCClient(t, grpc)
+		// Data
+		p := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-transformers": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name            string
+			generativeModel string
+		}{
+			{
+				name:            "tinyllama",
+				generativeModel: "tinyllama",
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				class.ModuleConfig = map[string]interface{}{
+					"generative-ollama": map[string]interface{}{
+						"apiEndpoint": ollamaApiEndpoint,
+						"model":       tt.generativeModel,
+					},
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					planets.InsertObjects(t, class.Class)
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, planet := range p {
+						t.Run(planet.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+							require.IsType(t, []float32{}, obj.Vectors["description"])
+							assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+						})
+					}
+				})
+				// generative task
+				t.Run("create a tweet", func(t *testing.T) {
+					planets.CreateTweetTest(t, class.Class)
+				})
+				t.Run("create a tweet with params", func(t *testing.T) {
+					params := "ollama:{temperature:0.1}"
+					planets.CreateTweetTestWithParams(t, class.Class, params)
+				})
+				t.Run("create a tweet using grpc", func(t *testing.T) {
+					planets.CreateTweetTestGRPC(t, class.Class)
+				})
+				t.Run("create a tweet with params using grpc", func(t *testing.T) {
+					params := &pb.GenerativeProvider_Ollama{
+						Ollama: &pb.GenerativeOllama{
+							Model:       grpchelper.ToPtr(tt.generativeModel),
+							Temperature: grpchelper.ToPtr(0.9),
+						},
+					}
+					planets.CreateTweetTestWithParamsGRPC(t, class.Class, &pb.GenerativeProvider{
+						ReturnMetadata: false, // no metadata for ollama
+						Kind:           params,
+					})
+				})
+				t.Run("check if other properties are being added to prompt", func(t *testing.T) {
+					prompt := "Write a summary using: planet's name: {name}, mean radius: {meanRadius}, moons: {satellites}, surface temperatures [min,mean,max]: {surfaceTemperaturesCelcius} and is habitable: {isHabitable} information"
+					planets.CreatePromptTestWithParamsWithDebug(t, class.Class, prompt, "", true)
+				})
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-ollama/setup_test.go

@@ -0,0 +1,50 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeOllama_SingleNode(t *testing.T) {
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpointREST := compose.GetWeaviate().URI()
+	endpointGRPC := compose.GetWeaviate().GrpcURI()
+	ollamaApiEndpoint := compose.GetOllamaGenerative().GetEndpoint("apiEndpoint")
+
+	t.Run("tests", testGenerativeOllama(endpointREST, endpointGRPC, ollamaApiEndpoint))
+}
+
+func createSingleNodeEnvironment(ctx context.Context,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules().
+		WithWeaviateWithGRPC().
+		WithWeaviateEnv("MODULES_CLIENT_TIMEOUT", "120s").
+		Start(ctx)
+	return
+}
+
+func composeModules() (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecTransformers().
+		WithGenerativeOllama()
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-openai/generative_openai_test.go

@@ -0,0 +1,216 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeOpenAI(rest, grpc string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(rest)
+		helper.SetupGRPCClient(t, grpc)
+		// Define path to test/helper/sample-schema/planets/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/planets/data"
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-transformers": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name               string
+			generativeModel    string
+			absentModuleConfig bool
+			withImages         bool
+		}{
+			{
+				name:            "gpt-3.5-turbo",
+				generativeModel: "gpt-3.5-turbo",
+			},
+			{
+				name:            "gpt-4",
+				generativeModel: "gpt-4",
+			},
+			{
+				name:               "absent module config",
+				generativeModel:    "gpt-4",
+				absentModuleConfig: true,
+			},
+			{
+				name:            "gpt-4o-mini",
+				generativeModel: "gpt-4o-mini",
+				withImages:      true,
+			},
+			{
+				name:            "gpt-5",
+				generativeModel: "gpt-5",
+				withImages:      true,
+			},
+			{
+				name:            "gpt-5-mini",
+				generativeModel: "gpt-5-mini",
+				withImages:      true,
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				if tt.absentModuleConfig {
+					t.Log("skipping adding module config configuration to class")
+				} else {
+					class.ModuleConfig = map[string]interface{}{
+						"generative-openai": map[string]interface{}{
+							"model": tt.generativeModel,
+						},
+					}
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					if tt.withImages {
+						planets.InsertObjectsWithImages(t, class.Class, dataFolderPath)
+					} else {
+						planets.InsertObjects(t, class.Class)
+					}
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, planet := range data {
+						t.Run(planet.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+							require.IsType(t, []float32{}, obj.Vectors["description"])
+							assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+						})
+					}
+				})
+				// generative task
+				t.Run("create a tweet", func(t *testing.T) {
+					planets.CreateTweetTest(t, class.Class)
+				})
+				t.Run("create a tweet with params", func(t *testing.T) {
+					params := "openai:{temperature:1.0}"
+					if tt.absentModuleConfig {
+						params = fmt.Sprintf("openai:{temperature:1.0 model:\"%s\" baseURL:\"https://api.openai.com\" isAzure:false}", tt.generativeModel)
+					}
+					planets.CreateTweetTestWithParams(t, class.Class, params)
+				})
+				t.Run("create a tweet using grpc", func(t *testing.T) {
+					planets.CreateTweetTestGRPC(t, class.Class)
+				})
+
+				params := func() *pb.GenerativeOpenAI {
+					params := &pb.GenerativeOpenAI{
+						Model:       grpchelper.ToPtr(tt.generativeModel),
+						MaxTokens:   grpchelper.ToPtr(int64(2000)),
+						Temperature: grpchelper.ToPtr(1.0),
+						N:           grpchelper.ToPtr(int64(8)),
+					}
+					if !strings.HasPrefix(tt.generativeModel, "gpt-5") {
+						// gpt-5 models don't support topP, presencePenalty and frequencyPenalty parameters
+						params.TopP = grpchelper.ToPtr(0.9)
+						params.PresencePenalty = grpchelper.ToPtr(0.9)
+						params.FrequencyPenalty = grpchelper.ToPtr(0.9)
+					}
+					if strings.HasPrefix(tt.generativeModel, "gpt-4o") {
+						// increase the max tokens
+						params.MaxTokens = grpchelper.ToPtr(int64(5000))
+					}
+					if tt.absentModuleConfig {
+						params.BaseUrl = grpchelper.ToPtr("https://api.openai.com")
+					}
+					return params
+				}
+				t.Run("create a tweet with params using grpc", func(t *testing.T) {
+					planets.CreateTweetTestWithParamsGRPC(t, class.Class, &pb.GenerativeProvider{
+						ReturnMetadata: true,
+						Kind: &pb.GenerativeProvider_Openai{
+							Openai: params(),
+						},
+					})
+				})
+				if tt.withImages {
+					t.Run("image prompt", func(t *testing.T) {
+						t.Run("graphql", func(t *testing.T) {
+							prompt := "Describe image"
+							params := "openai:{imageProperties:\"image\"}"
+							planets.CreatePromptTestWithParams(t, class.Class, prompt, params)
+						})
+
+						singlePrompt := "Give a short answer: What's on the image?"
+						groupPrompt := "Give a short answer: What are on the following images?"
+
+						t.Run("grpc server stored images", func(t *testing.T) {
+							params := params()
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Openai{Openai: params},
+							})
+						})
+
+						t.Run("grpc user provided images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Openai{Openai: params},
+							})
+						})
+
+						t.Run("grpc mixed images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Openai{Openai: params},
+							})
+						})
+					})
+				}
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-openai/setup_test.go

@@ -0,0 +1,58 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeOpenAI_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("OPENAI_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, OPENAI_APIKEY environment variable not present")
+	}
+	organization := os.Getenv("OPENAI_ORGANIZATION")
+	if organization == "" {
+		t.Skip("skipping, OPENAI_ORGANIZATION environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey, organization)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpointREST := compose.GetWeaviate().URI()
+	endpointGRPC := compose.GetWeaviate().GrpcURI()
+
+	t.Run("tests", testGenerativeOpenAI(endpointREST, endpointGRPC))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey, organization string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey, organization).
+		WithWeaviateWithGRPC().
+		WithWeaviateEnv("MODULES_CLIENT_TIMEOUT", "180s").
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey, organization string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecTransformers().
+		WithGenerativeOpenAI(apiKey, organization, "")
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-xai/generative_xai_test.go

@@ -0,0 +1,195 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/helper"
+	grpchelper "github.com/weaviate/weaviate/test/helper/grpc"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeXAI(rest, grpc string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(rest)
+		helper.SetupGRPCClient(t, grpc)
+		// Define path to test/helper/sample-schema/planets/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/planets/data"
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]any{
+					"text2vec-transformers": map[string]any{
+						"properties":         []any{"description"},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		tests := []struct {
+			name               string
+			generativeModel    string
+			absentModuleConfig bool
+			withImages         bool
+		}{
+			{
+				name:            "grok-2-latest",
+				generativeModel: "grok-2-latest",
+			},
+			{
+				name:            "grok-2-1212",
+				generativeModel: "grok-2-1212",
+			},
+			{
+				name:               "absent module config",
+				generativeModel:    "grok-2-1212",
+				absentModuleConfig: true,
+			},
+			{
+				name:            "grok-2-vision-1212",
+				generativeModel: "grok-2-vision-1212",
+				withImages:      true,
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				if tt.absentModuleConfig {
+					t.Log("skipping adding module config configuration to class")
+				} else {
+					class.ModuleConfig = map[string]any{
+						"generative-xai": map[string]any{
+							"model": tt.generativeModel,
+						},
+					}
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				// create objects
+				t.Run("create objects", func(t *testing.T) {
+					if tt.withImages {
+						planets.InsertObjectsWithImages(t, class.Class, dataFolderPath)
+					} else {
+						planets.InsertObjects(t, class.Class)
+					}
+				})
+				t.Run("check objects existence", func(t *testing.T) {
+					for _, planet := range data {
+						t.Run(planet.ID.String(), func(t *testing.T) {
+							obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+							require.NoError(t, err)
+							require.NotNil(t, obj)
+							require.Len(t, obj.Vectors, 1)
+							require.IsType(t, []float32{}, obj.Vectors["description"])
+							assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+						})
+					}
+				})
+				// generative task
+				t.Run("create a tweet", func(t *testing.T) {
+					planets.CreateTweetTest(t, class.Class)
+				})
+				t.Run("create a tweet with params", func(t *testing.T) {
+					params := "xai:{temperature:0.1}"
+					if tt.absentModuleConfig {
+						params = fmt.Sprintf("xai:{temperature:0.1 model:\"%s\" baseURL:\"https://api.x.ai\"}", tt.generativeModel)
+					}
+					planets.CreateTweetTestWithParams(t, class.Class, params)
+				})
+				t.Run("create a tweet using grpc", func(t *testing.T) {
+					planets.CreateTweetTestGRPC(t, class.Class)
+				})
+
+				params := func() *pb.GenerativeXAI {
+					params := &pb.GenerativeXAI{
+						MaxTokens:   grpchelper.ToPtr(int64(90)),
+						Model:       grpchelper.ToPtr(tt.generativeModel),
+						Temperature: grpchelper.ToPtr(0.9),
+						TopP:        grpchelper.ToPtr(0.9),
+					}
+					if tt.absentModuleConfig {
+						params.BaseUrl = grpchelper.ToPtr("https://api.x.ai")
+					}
+					return params
+				}
+				t.Run("create a tweet with params using grpc", func(t *testing.T) {
+					planets.CreateTweetTestWithParamsGRPC(t, class.Class, &pb.GenerativeProvider{
+						ReturnMetadata: true,
+						Kind: &pb.GenerativeProvider_Xai{
+							Xai: params(),
+						},
+					})
+				})
+				if tt.withImages {
+					t.Run("image prompt", func(t *testing.T) {
+						t.Run("graphql", func(t *testing.T) {
+							prompt := "Describe image"
+							params := "xai:{imageProperties:\"image\"}"
+							planets.CreatePromptTestWithParams(t, class.Class, prompt, params)
+						})
+
+						singlePrompt := "Give a short answer: What's on the image?"
+						groupPrompt := "Give a short answer: What are on the following images?"
+
+						t.Run("grpc server stored images", func(t *testing.T) {
+							params := params()
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Xai{Xai: params},
+							})
+						})
+
+						t.Run("grpc user provided images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Xai{Xai: params},
+							})
+						})
+
+						t.Run("grpc mixed images", func(t *testing.T) {
+							earth, err := planets.GetImageBlob(dataFolderPath, "earth")
+							require.NoError(t, err)
+							mars, err := planets.GetImageBlob(dataFolderPath, "mars")
+							require.NoError(t, err)
+
+							params := params()
+							params.Images = &pb.TextArray{Values: []string{earth, mars}}
+							params.ImageProperties = &pb.TextArray{Values: []string{"image"}}
+							planets.CreatePromptTestWithParamsGRPC(t, class.Class, singlePrompt, groupPrompt, &pb.GenerativeProvider{
+								ReturnMetadata: true,
+								Kind:           &pb.GenerativeProvider_Xai{Xai: params},
+							})
+						})
+					})
+				}
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/generative-xai/setup_test.go

@@ -0,0 +1,54 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeOpenAI_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("XAI_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, XAI_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpointREST := compose.GetWeaviate().URI()
+	endpointGRPC := compose.GetWeaviate().GrpcURI()
+
+	t.Run("tests", testGenerativeXAI(endpointREST, endpointGRPC))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey).
+		WithWeaviateWithGRPC().
+		WithWeaviateEnv("MODULES_CLIENT_TIMEOUT", "120s").
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecTransformers().
+		WithGenerativeXAI(apiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/img2vec-neural/neural_test.go

@@ -0,0 +1,103 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"encoding/base64"
+	"fmt"
+	"io"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+)
+
+func Test_Img2VecNeural(t *testing.T) {
+	helper.SetupClient(os.Getenv(weaviateEndpoint))
+
+	fashionItemClass := &models.Class{
+		Class:      "FashionItem",
+		Vectorizer: "img2vec-neural",
+		ModuleConfig: map[string]interface{}{
+			"img2vec-neural": map[string]interface{}{
+				"imageFields": []string{"image"},
+			},
+		},
+		Properties: []*models.Property{
+			{
+				Name:     "image",
+				DataType: schema.DataTypeBlob.PropString(),
+			},
+			{
+				Name:         "description",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+		},
+	}
+
+	helper.CreateClass(t, fashionItemClass)
+	defer helper.DeleteClass(t, fashionItemClass.Class)
+
+	getBase64EncodedTestImage := func() string {
+		image, err := os.Open("./data/pixel.png")
+		require.Nil(t, err)
+		require.NotNil(t, image)
+		content, err := io.ReadAll(image)
+		require.Nil(t, err)
+		return base64.StdEncoding.EncodeToString(content)
+	}
+
+	t.Run("import data", func(t *testing.T) {
+		base64Image := getBase64EncodedTestImage()
+		obj := &models.Object{
+			Class: fashionItemClass.Class,
+			Properties: map[string]interface{}{
+				"image":       base64Image,
+				"description": "A single black pixel",
+			},
+		}
+		helper.CreateObject(t, obj)
+	})
+
+	t.Run("perform nearImage query", func(t *testing.T) {
+		queryTemplate := `
+		{
+			Get {
+				FashionItem(
+					nearImage: {
+						image: "%s"
+					}
+				){
+					image
+					description
+					_additional{vector}
+				}
+			}
+		}`
+		query := fmt.Sprintf(queryTemplate, getBase64EncodedTestImage())
+		result := graphqlhelper.AssertGraphQL(t, helper.RootAuth, query)
+		fashionItems := result.Get("Get", "FashionItem").AsSlice()
+		require.True(t, len(fashionItems) > 0)
+		item, ok := fashionItems[0].(map[string]interface{})
+		require.True(t, ok)
+		assert.NotNil(t, item["image"])
+		assert.NotNil(t, item["description"])
+		vector := item["_additional"].(map[string]interface{})["vector"]
+		assert.NotNil(t, vector)
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/img2vec-neural/setup_test.go

@@ -0,0 +1,44 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+const weaviateEndpoint = "WEAVIATE_ENDPOINT"
+
+func TestMain(m *testing.M) {
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviate().
+		WithText2VecContextionary().
+		WithImg2VecNeural().
+		Start(ctx)
+	if err != nil {
+		panic(errors.Wrapf(err, "cannot start"))
+	}
+
+	os.Setenv(weaviateEndpoint, compose.GetWeaviate().URI())
+	code := m.Run()
+
+	if err := compose.Terminate(ctx); err != nil {
+		panic(errors.Wrapf(err, "cannot terminate"))
+	}
+
+	os.Exit(code)
+}

platform/dbops/binaries/weaviate-src/test/modules/many-generative/many_generative_test.go

@@ -0,0 +1,101 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/planets"
+)
+
+func testGenerativeManyModules(host, ollamaApiEndpoint, region, gcpProject string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Data
+		data := planets.Planets
+		// Define class
+		class := planets.BaseClass("PlanetsGenerativeTest")
+		class.VectorConfig = map[string]models.VectorConfig{
+			"description": {
+				Vectorizer: map[string]interface{}{
+					"text2vec-transformers": map[string]interface{}{
+						"properties":         []interface{}{"description"},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		class.ModuleConfig = map[string]interface{}{
+			"generative-aws": map[string]interface{}{
+				"service": "bedrock",
+				"region":  region,
+				"model":   "amazon.titan-text-lite-v1",
+			},
+			"generative-google": map[string]interface{}{
+				"projectId": gcpProject,
+				"modelId":   "gemini-1.0-pro",
+			},
+			"generative-ollama": map[string]interface{}{
+				"apiEndpoint": ollamaApiEndpoint,
+			},
+		}
+		// create schema
+		helper.CreateClass(t, class)
+		defer helper.DeleteClass(t, class.Class)
+		// create objects
+		t.Run("create objects", func(t *testing.T) {
+			planets.InsertObjects(t, class.Class)
+		})
+		t.Run("check objects existence", func(t *testing.T) {
+			for _, planet := range data {
+				t.Run(planet.ID.String(), func(t *testing.T) {
+					obj, err := helper.GetObject(t, class.Class, planet.ID, "vector")
+					require.NoError(t, err)
+					require.NotNil(t, obj)
+					require.Len(t, obj.Vectors, 1)
+					require.IsType(t, []float32{}, obj.Vectors["description"])
+					assert.True(t, len(obj.Vectors["description"].([]float32)) > 0)
+				})
+			}
+		})
+		// generative task with params
+		tests := []struct {
+			name   string
+			params string
+		}{
+			{
+				name:   "ollama",
+				params: `ollama:{temperature:0.1 model:"tinyllama"}`,
+			},
+			{
+				name:   "aws",
+				params: `aws:{temperature:0.9 model:"ai21.j2-mid-v1"}`,
+			},
+			{
+				name:   "google",
+				params: `google:{topP:0.8 topK:30 model:"chat-bison"}`,
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				t.Run("create a tweet with params", func(t *testing.T) {
+					planets.CreateTweetTestWithParams(t, class.Class, tt.params)
+				})
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/many-generative/setup_test.go

@@ -0,0 +1,100 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestGenerativeManyModules_SingleNode(t *testing.T) {
+	// AWS
+	accessKey := os.Getenv("AWS_ACCESS_KEY")
+	if accessKey == "" {
+		accessKey = os.Getenv("AWS_ACCESS_KEY_ID")
+		if accessKey == "" {
+			t.Skip("skipping, AWS_ACCESS_KEY environment variable not present")
+		}
+	}
+	secretKey := os.Getenv("AWS_SECRET_KEY")
+	if secretKey == "" {
+		secretKey = os.Getenv("AWS_SECRET_ACCESS_KEY")
+		if secretKey == "" {
+			t.Skip("skipping, AWS_SECRET_KEY environment variable not present")
+		}
+	}
+	sessionToken := os.Getenv("AWS_SESSION_TOKEN")
+	if sessionToken == "" {
+		t.Skip("skipping, AWS_SESSION_TOKEN environment variable not present")
+	}
+	region := os.Getenv("AWS_REGION")
+	if region == "" {
+		t.Skip("skipping, AWS_REGION environment variable not present")
+	}
+	// Google
+	gcpProject := os.Getenv("GCP_PROJECT")
+	if gcpProject == "" {
+		t.Skip("skipping, GCP_PROJECT environment variable not present")
+	}
+	googleApiKey := os.Getenv("GOOGLE_APIKEY")
+	if googleApiKey == "" {
+		t.Skip("skipping, GOOGLE_APIKEY environment variable not present")
+	}
+	// OpenAI
+	openAIApiKey := os.Getenv("OPENAI_APIKEY")
+	openAIOrganization := os.Getenv("OPENAI_ORGANIZATION")
+	// Cohere
+	cohereApiKey := os.Getenv("COHERE_APIKEY")
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, accessKey, secretKey, sessionToken,
+		openAIApiKey, openAIOrganization, googleApiKey, cohereApiKey,
+	)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+	ollamaApiEndpoint := compose.GetOllamaGenerative().GetEndpoint("apiEndpoint")
+
+	t.Run("tests", testGenerativeManyModules(endpoint, ollamaApiEndpoint, region, gcpProject))
+}
+
+func createSingleNodeEnvironment(ctx context.Context,
+	accessKey, secretKey, sessionToken string,
+	openAIApiKey, openAIOrganization string,
+	googleApiKey, cohereApiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(accessKey, secretKey, sessionToken,
+		openAIApiKey, openAIOrganization, googleApiKey, cohereApiKey,
+	).
+		WithWeaviate().
+		Start(ctx)
+	return
+}
+
+func composeModules(accessKey, secretKey, sessionToken string,
+	openAIApiKey, openAIOrganization string,
+	googleApiKey, cohereApiKey string,
+) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithText2VecTransformers().
+		WithGenerativeOllama().
+		WithGenerativeAWS(accessKey, secretKey, sessionToken).
+		WithGenerativeGoogle(googleApiKey).
+		WithGenerativeOpenAI(openAIApiKey, openAIOrganization, "").
+		WithGenerativeCohere(cohereApiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/many-modules/api_based_modules_sanity_test.go

@@ -0,0 +1,50 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func apiBasedModulesTests(endpoint string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(endpoint)
+
+		t.Run("check enabled modules", func(t *testing.T) {
+			meta := helper.GetMeta(t)
+			require.NotNil(t, meta)
+
+			expectedModuleNames := []string{
+				"generative-cohere", "generative-google", "generative-openai", "generative-aws", "generative-anyscale", "generative-friendliai",
+				"text2vec-cohere", "text2vec-contextionary", "text2vec-openai", "text2vec-huggingface",
+				"text2vec-google", "text2vec-aws", "text2vec-transformers", "qna-openai", "reranker-cohere",
+				"text2vec-voyageai", "reranker-voyageai",
+			}
+
+			modules, ok := meta.Modules.(map[string]interface{})
+			require.True(t, ok)
+			assert.True(t, len(modules) >= len(expectedModuleNames))
+
+			moduleNames := []string{}
+			for name := range modules {
+				moduleNames = append(moduleNames, name)
+			}
+			for _, name := range expectedModuleNames {
+				assert.Contains(t, moduleNames, name)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/many-modules/many_modules_openai_test.go

@@ -0,0 +1,143 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func createSchemaOpenAISanityChecks(endpoint string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(endpoint)
+
+		vectorizer := "text2vec-openai"
+		class := &models.Class{
+			Class: "OpenAI",
+			Properties: []*models.Property{
+				{
+					Name:     "text",
+					DataType: []string{schema.DataTypeText.String()},
+				},
+			},
+			Vectorizer: vectorizer,
+		}
+		tests := []struct {
+			name                  string
+			text2vecOpenAI        map[string]interface{}
+			expectDefaultSettings bool
+		}{
+			{
+				name: "model: text-embedding-3-large, dimensions: 256, vectorizeClassName: false",
+				text2vecOpenAI: map[string]interface{}{
+					"vectorizeClassName": false,
+					"model":              "text-embedding-3-large",
+					"dimensions":         256,
+				},
+			},
+			{
+				name: "model: text-embedding-3-large, dimensions: 1024, vectorizeClassName: false",
+				text2vecOpenAI: map[string]interface{}{
+					"vectorizeClassName": false,
+					"model":              "text-embedding-3-large",
+					"dimensions":         1024,
+				},
+			},
+			{
+				name: "model: text-embedding-3-large, dimensions: 3072, vectorizeClassName: false",
+				text2vecOpenAI: map[string]interface{}{
+					"vectorizeClassName": false,
+					"model":              "text-embedding-3-large",
+					"dimensions":         3072,
+				},
+			},
+			{
+				name: "model: text-embedding-3-small, dimensions: 512, vectorizeClassName: true",
+				text2vecOpenAI: map[string]interface{}{
+					"vectorizeClassName": true,
+					"model":              "text-embedding-3-small",
+					"dimensions":         512,
+				},
+			},
+			{
+				name: "model: text-embedding-3-small, dimensions: 1536, vectorizeClassName: false",
+				text2vecOpenAI: map[string]interface{}{
+					"vectorizeClassName": false,
+					"model":              "text-embedding-3-small",
+					"dimensions":         1536,
+				},
+			},
+			{
+				name: "model: text-embedding-3-small, dimensions: 1536, vectorizeClassName: true",
+				text2vecOpenAI: map[string]interface{}{
+					"vectorizeClassName": true,
+					"model":              "text-embedding-3-small",
+					"dimensions":         1536,
+				},
+			},
+			{
+				name: "model: ada, vectorizeClassName: false",
+				text2vecOpenAI: map[string]interface{}{
+					"vectorizeClassName": false,
+					"model":              "ada",
+				},
+			},
+			{
+				name:                  "nil settings",
+				text2vecOpenAI:        nil,
+				expectDefaultSettings: true,
+			},
+			{
+				name:                  "empty settings",
+				text2vecOpenAI:        map[string]interface{}{},
+				expectDefaultSettings: true,
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				class.ModuleConfig = map[string]interface{}{
+					vectorizer: tt.text2vecOpenAI,
+				}
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+				verifyClass := helper.GetClass(t, class.Class)
+				moduleConfig, ok := verifyClass.ModuleConfig.(map[string]interface{})
+				require.True(t, ok)
+				require.NotEmpty(t, moduleConfig)
+				text2vecOpenAI, ok := moduleConfig[vectorizer].(map[string]interface{})
+				require.True(t, ok)
+				require.NotEmpty(t, text2vecOpenAI)
+				if tt.expectDefaultSettings {
+					assert.Equal(t, "text-embedding-3-small", text2vecOpenAI["model"])
+					assert.Equal(t, true, text2vecOpenAI["vectorizeClassName"])
+				} else {
+					assert.Equal(t, tt.text2vecOpenAI["model"], text2vecOpenAI["model"])
+					assert.Equal(t, tt.text2vecOpenAI["vectorizeClassName"], text2vecOpenAI["vectorizeClassName"])
+					expectedDimensions, ok := tt.text2vecOpenAI["dimensions"]
+					if ok {
+						dimensions, ok := text2vecOpenAI["dimensions"].(json.Number)
+						require.True(t, ok)
+						dimensionsInt64, err := dimensions.Int64()
+						require.NoError(t, err)
+						assert.Equal(t, expectedDimensions, int(dimensionsInt64))
+					}
+				}
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/many-modules/many_modules_sanity_test.go

@@ -0,0 +1,198 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/books"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multishard"
+)
+
+func manyModulesTests(endpoint string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(endpoint)
+
+		t.Run("check enabled modules", func(t *testing.T) {
+			meta := helper.GetMeta(t)
+			require.NotNil(t, meta)
+
+			expectedModuleNames := []string{
+				"generative-cohere", "generative-google", "generative-openai", "generative-aws", "generative-anyscale", "generative-friendliai",
+				"generative-anthropic", "text2vec-cohere", "text2vec-contextionary", "text2vec-openai", "text2vec-huggingface",
+				"text2vec-google", "text2vec-aws", "text2vec-transformers", "qna-openai", "reranker-cohere",
+				"text2vec-voyageai", "reranker-voyageai",
+			}
+
+			modules, ok := meta.Modules.(map[string]interface{})
+			require.True(t, ok)
+			assert.Len(t, modules, len(expectedModuleNames))
+
+			moduleNames := []string{}
+			for name := range modules {
+				moduleNames = append(moduleNames, name)
+			}
+			assert.ElementsMatch(t, expectedModuleNames, moduleNames)
+		})
+
+		booksClass := books.ClassContextionaryVectorizer()
+		multiShardClass := multishard.ClassContextionaryVectorizer()
+		helper.CreateClass(t, booksClass)
+		helper.CreateClass(t, multiShardClass)
+		defer helper.DeleteClass(t, booksClass.Class)
+		defer helper.DeleteClass(t, multiShardClass.Class)
+
+		t.Run("import data", func(t *testing.T) {
+			for _, book := range books.Objects() {
+				helper.CreateObject(t, book)
+				helper.AssertGetObjectEventually(t, book.Class, book.ID)
+			}
+			for _, multishard := range multishard.Objects() {
+				helper.CreateObject(t, multishard)
+				helper.AssertGetObjectEventually(t, multishard.Class, multishard.ID)
+			}
+		})
+
+		t.Run("sanity checks", func(t *testing.T) {
+			concepts := []string{
+				"Frank", "Herbert", "Dune", "Book", "Project", "Hail", "Mary",
+				"The Lord of the Ice Garden", "Ice Garden", "science", "fiction",
+				"fantasy novel", "novelist",
+			}
+			checkResults := func(query string) {
+				result := graphqlhelper.AssertGraphQL(t, helper.RootAuth, query)
+				books := result.Get("Get", "Books").AsSlice()
+				require.True(t, len(books) > 0)
+				results, ok := books[0].(map[string]interface{})
+				require.True(t, ok)
+				assert.True(t, results["title"] != nil)
+			}
+
+			t.Run("nearText queries", func(t *testing.T) {
+				queryTemplate := `
+			{
+				Get {
+					Books(
+						nearText: {
+							concepts: ["%s"]
+						}
+					){
+						title
+					}
+				}
+			}`
+				for _, concept := range concepts {
+					checkResults(fmt.Sprintf(queryTemplate, concept))
+				}
+			})
+			t.Run("nearObject queries", func(t *testing.T) {
+				queryTemplate := `
+			{
+				Get {
+					Books(
+						nearObject: {
+							id: "%s"
+						}
+					){
+						title
+					}
+				}
+			}`
+				ids := []strfmt.UUID{books.Dune, books.ProjectHailMary, books.TheLordOfTheIceGarden}
+				for _, id := range ids {
+					checkResults(fmt.Sprintf(queryTemplate, id))
+				}
+			})
+			t.Run("nearVector queries", func(t *testing.T) {
+				getVectors := func() []string {
+					query := `
+				{
+					Get {
+						Books(limit: 3){ _additional{ vector } }
+					}
+				}`
+					result := graphqlhelper.AssertGraphQL(t, helper.RootAuth, query)
+					books := result.Get("Get", "Books").AsSlice()
+					require.True(t, len(books) == 3)
+					vectors := make([]string, 3)
+					for i := 0; i < 3; i++ {
+						results, ok := books[i].(map[string]interface{})
+						require.True(t, ok)
+						vector, ok := results["_additional"].(map[string]interface{})["vector"].([]interface{})
+						require.True(t, ok)
+						vec, err := json.Marshal(vector)
+						require.Nil(t, err)
+						vectors[i] = string(vec)
+					}
+					return vectors
+				}
+				vectors := getVectors()
+				queryTemplate := `
+			{
+				Get {
+					Books(
+						nearVector: {
+							vector: %s
+						}
+					){
+						title
+					}
+				}
+			}`
+				for _, vector := range vectors {
+					checkResults(fmt.Sprintf(queryTemplate, vector))
+				}
+			})
+			t.Run("hybrid queries", func(t *testing.T) {
+				queryTemplate := `
+			{
+				Get {
+					Books(
+						hybrid: {
+							query: "%s"
+						}
+					){
+						title
+					}
+				}
+			}`
+				for _, concept := range concepts {
+					checkResults(fmt.Sprintf(queryTemplate, concept))
+				}
+			})
+			t.Run("bm25 queries", func(t *testing.T) {
+				queryTemplate := `
+			{
+				Get {
+					Books(
+						bm25:{
+							query: "%s"
+						}
+					){
+						title
+					}
+				}
+			}`
+				for _, concept := range []string{"Frank", "Project Hail Mary", "Dune", "Project", "Hail", "Mary"} {
+					checkResults(fmt.Sprintf(queryTemplate, concept))
+				}
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/many-modules/setup_test.go

@@ -0,0 +1,101 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func Test_ManyModules_SingleNode(t *testing.T) {
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+	t.Run("many modules", manyModulesTests(endpoint))
+	t.Run("create schema with specific text2vec-openai settings", createSchemaOpenAISanityChecks(endpoint))
+}
+
+func Test_ManyModules_SingleNode_Enabled_API_Based_Modules(t *testing.T) {
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironmentWithEnabledApiBasedModules(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+	t.Run("api based modules", apiBasedModulesTests(endpoint))
+}
+
+func Test_ManyModules_Cluster(t *testing.T) {
+	ctx := context.Background()
+	compose, err := createClusterEnvironment(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+	t.Run("many modules", manyModulesTests(endpoint))
+	t.Run("create schema with specific text2vec-openai settings", createSchemaOpenAISanityChecks(endpoint))
+}
+
+func createSingleNodeEnvironment(ctx context.Context) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules().
+		WithWeaviate().
+		Start(ctx)
+	return
+}
+
+func createSingleNodeEnvironmentWithEnabledApiBasedModules(ctx context.Context) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules().
+		WithWeaviate().
+		Start(ctx)
+	return
+}
+
+func createClusterEnvironment(ctx context.Context) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules().
+		WithWeaviateCluster(3).
+		Start(ctx)
+	return
+}
+
+func composeModules() (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithWeaviateEnv("API_BASED_MODULES_DISABLED", "true").
+		WithText2VecContextionary().
+		WithText2VecTransformers().
+		WithText2VecOpenAI(os.Getenv("OPENAI_APIKEY"), os.Getenv("OPENAI_ORGANIZATION"), os.Getenv("AZURE_APIKEY")).
+		WithText2VecCohere(os.Getenv("COHERE_APIKEY")).
+		WithText2VecVoyageAI(os.Getenv("VOYAGEAI_APIKEY")).
+		WithText2VecGoogle(os.Getenv("GOOGLE_APIKEY")).
+		WithText2VecHuggingFace(os.Getenv("HUGGINGFACE_APIKEY")).
+		WithText2VecAWS(os.Getenv("AWS_ACCESS_KEY_ID"), os.Getenv("AWS_SECRET_ACCESS_KEY"), os.Getenv("AWS_SESSION_TOKEN")).
+		WithGenerativeOpenAI(os.Getenv("OPENAI_APIKEY"), os.Getenv("OPENAI_ORGANIZATION"), os.Getenv("AZURE_APIKEY")).
+		WithGenerativeCohere(os.Getenv("COHERE_APIKEY")).
+		WithGenerativeGoogle(os.Getenv("GOOGLE_APIKEY")).
+		WithGenerativeAWS(os.Getenv("AWS_ACCESS_KEY_ID"), os.Getenv("AWS_SECRET_ACCESS_KEY"), os.Getenv("AWS_SESSION_TOKEN")).
+		WithGenerativeAnyscale().
+		WithGenerativeAnthropic(os.Getenv("ANTHROPIC_APIKEY")).
+		WithGenerativeFriendliAI(os.Getenv("FRIENDLI_TOKEN")).
+		WithQnAOpenAI().
+		WithRerankerCohere().
+		WithRerankerVoyageAI()
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2multivec-jinaai/multi2multivec_jinaai_test.go

@@ -0,0 +1,85 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multimodal"
+)
+
+func testMulti2MultivecJinaAI(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Define path to test/helper/sample-schema/multimodal/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/multimodal/data"
+		// Define class
+		vectorizerName := "multi2multivec-jinaai"
+		className := "ClipTest"
+		class := multimodal.BaseClass(className, false)
+		class.VectorConfig = map[string]models.VectorConfig{
+			"clip": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"imageFields": []interface{}{multimodal.PropertyImage},
+					},
+				},
+				VectorIndexType:   "hnsw",
+				VectorIndexConfig: hnsw.MultivectorConfig{Enabled: true},
+			},
+		}
+		// create schema
+		helper.CreateClass(t, class)
+		defer helper.DeleteClass(t, class.Class)
+
+		t.Run("import data", func(t *testing.T) {
+			multimodal.InsertObjects(t, dataFolderPath, class.Class, false)
+		})
+
+		t.Run("check objects", func(t *testing.T) {
+			multimodal.CheckObjects(t, dataFolderPath, class.Class, nil, []string{"clip"})
+		})
+
+		t.Run("nearImage", func(t *testing.T) {
+			blob, err := multimodal.GetImageBlob(dataFolderPath, 2)
+			require.NoError(t, err)
+			targetVector := "clip"
+			nearMediaArgument := fmt.Sprintf(`
+				nearImage: {
+					image: "%s"
+					targetVectors: ["%s"]
+				}
+			`, blob, targetVector)
+			titleProperty := multimodal.PropertyImageTitle
+			titlePropertyValue := "waterfalls"
+			multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, nil)
+		})
+
+		t.Run("nearText", func(t *testing.T) {
+			titleProperty := multimodal.PropertyImageTitle
+			titlePropertyValue := "waterfalls"
+			targetVector := "clip"
+			nearMediaArgument := fmt.Sprintf(`
+				nearText: {
+					concepts: "%s"
+					targetVectors: ["%s"]
+				}
+			`, titlePropertyValue, targetVector)
+			multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, nil)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2multivec-jinaai/setup_test.go

@@ -0,0 +1,40 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestMulti2VecJinaAI_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("JINAAI_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, JINAAI_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviate().
+		WithMulti2MultivecJinaAI(apiKey).
+		Start(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("multi2multivec-jinaai", testMulti2MultivecJinaAI(endpoint))
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-bind/bind_test.go

@@ -0,0 +1,84 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/books"
+)
+
+func Test_Bind(t *testing.T) {
+	helper.SetupClient(os.Getenv(weaviateEndpoint))
+	booksClass := books.ClassBindVectorizer()
+	helper.CreateClass(t, booksClass)
+	defer helper.DeleteClass(t, booksClass.Class)
+
+	t.Run("add data to Books schema", func(t *testing.T) {
+		for _, book := range books.Objects() {
+			helper.CreateObject(t, book)
+			helper.AssertGetObjectEventually(t, book.Class, book.ID)
+		}
+	})
+
+	tests := []struct {
+		concept       string
+		expectedTitle string
+	}{
+		{
+			concept:       "Dune",
+			expectedTitle: "Dune",
+		},
+		{
+			concept:       "three",
+			expectedTitle: "The Lord of the Ice Garden",
+		},
+	}
+	for _, tt := range tests {
+		t.Run("query Books data with nearText", func(t *testing.T) {
+			result := graphqlhelper.AssertGraphQL(t, helper.RootAuth, fmt.Sprintf(`
+				{
+					Get {
+						Books(
+							limit: 1
+							nearText: {
+								concepts: ["%v"]
+								distance: 0.5
+							}
+						){
+							title
+							_additional {
+								distance
+							}
+						}
+					}
+				}
+			`, tt.concept))
+			books := result.Get("Get", "Books").AsSlice()
+			require.Len(t, books, 1)
+			title := books[0].(map[string]interface{})["title"]
+			assert.Equal(t, tt.expectedTitle, title)
+			distance := books[0].(map[string]interface{})["_additional"].(map[string]interface{})["distance"].(json.Number)
+			assert.NotNil(t, distance)
+			dist, err := distance.Float64()
+			require.Nil(t, err)
+			assert.Greater(t, dist, 0.0)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-bind/setup_test.go

@@ -0,0 +1,43 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+const weaviateEndpoint = "WEAVIATE_ENDPOINT"
+
+func TestMain(m *testing.M) {
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviate().
+		WithMulti2VecBind().
+		Start(ctx)
+	if err != nil {
+		panic(errors.Wrapf(err, "cannot start"))
+	}
+
+	os.Setenv(weaviateEndpoint, compose.GetWeaviate().URI())
+	code := m.Run()
+
+	if err := compose.Terminate(ctx); err != nil {
+		panic(errors.Wrapf(err, "cannot terminate"))
+	}
+
+	os.Exit(code)
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-clip/multi2vec_clip_test.go

@@ -0,0 +1,89 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multimodal"
+)
+
+func testMulti2VecClip(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Define path to test/helper/sample-schema/multimodal/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/multimodal/data"
+		// Define class
+		vectorizerName := "multi2vec-clip"
+		className := "ClipTest"
+		class := multimodal.BaseClass(className, false)
+		class.VectorConfig = map[string]models.VectorConfig{
+			"clip": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"imageFields":        []interface{}{multimodal.PropertyImage},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			"clip_weights": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"textFields":  []interface{}{multimodal.PropertyImageTitle, multimodal.PropertyImageDescription},
+						"imageFields": []interface{}{multimodal.PropertyImage},
+						"weights": map[string]interface{}{
+							"textFields":  []interface{}{0.05, 0.05},
+							"imageFields": []interface{}{0.9},
+						},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		// create schema
+		helper.CreateClass(t, class)
+		defer helper.DeleteClass(t, class.Class)
+
+		t.Run("import data", func(t *testing.T) {
+			multimodal.InsertObjects(t, dataFolderPath, class.Class, false)
+		})
+
+		t.Run("check objects", func(t *testing.T) {
+			multimodal.CheckObjects(t, dataFolderPath, class.Class, []string{"clip", "clip_weights"}, nil)
+		})
+
+		t.Run("nearImage", func(t *testing.T) {
+			blob, err := multimodal.GetImageBlob(dataFolderPath, 2)
+			require.NoError(t, err)
+			targetVector := "clip"
+			nearMediaArgument := fmt.Sprintf(`
+				nearImage: {
+					image: "%s"
+					targetVectors: ["%s"]
+				}
+			`, blob, targetVector)
+			titleProperty := multimodal.PropertyImageTitle
+			titlePropertyValue := "waterfalls"
+			targetVectors := map[string]int{
+				"clip":         512,
+				"clip_weights": 512,
+			}
+			multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, targetVectors)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-clip/setup_test.go

@@ -0,0 +1,35 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestMulti2VecClip_SingleNode(t *testing.T) {
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviate().
+		WithMulti2VecCLIP().
+		Start(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("multi2vec-clip", testMulti2VecClip(endpoint))
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-cohere/multi2vec_cohere_test.go

@@ -0,0 +1,86 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multimodal"
+)
+
+func testMulti2VecCohere(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Define path to test/helper/sample-schema/multimodal/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/multimodal/data"
+		// Define class
+		vectorizerName := "multi2vec-cohere"
+		className := "CohereClipTest"
+		class := multimodal.BaseClass(className, false)
+		class.VectorConfig = map[string]models.VectorConfig{
+			"clip": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"imageFields":        []interface{}{multimodal.PropertyImage},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			"clip_weights": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"model":       "embed-english-light-v3.0",
+						"textFields":  []interface{}{multimodal.PropertyImageTitle, multimodal.PropertyImageDescription},
+						"imageFields": []interface{}{multimodal.PropertyImage},
+						"weights": map[string]interface{}{
+							"textFields":  []interface{}{0.05, 0.05},
+							"imageFields": []interface{}{0.9},
+						},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		// create schema
+		helper.CreateClass(t, class)
+		defer helper.DeleteClass(t, class.Class)
+
+		t.Run("import data", func(t *testing.T) {
+			multimodal.InsertObjects(t, dataFolderPath, class.Class, false)
+		})
+
+		t.Run("nearImage", func(t *testing.T) {
+			blob, err := multimodal.GetImageBlob(dataFolderPath, 2)
+			require.NoError(t, err)
+			targetVector := "clip"
+			nearMediaArgument := fmt.Sprintf(`
+				nearImage: {
+					image: "%s"
+					targetVectors: ["%s"]
+				}
+			`, blob, targetVector)
+			titleProperty := multimodal.PropertyImageTitle
+			titlePropertyValue := "waterfalls"
+			targetVectors := map[string]int{
+				"clip":         1024,
+				"clip_weights": 384,
+			}
+			multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, targetVectors)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-cohere/setup_test.go

@@ -0,0 +1,51 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestMulti2VecCohere_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("COHERE_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, COHERE_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("multi2vec-cohere", testMulti2VecCohere(endpoint))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey).
+		WithWeaviate().
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithMulti2VecCohere(apiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-google/multi2vec_google_test.go

@@ -0,0 +1,154 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multimodal"
+)
+
+func testMulti2VecGoogle(host, gcpProject, location, vectorizerName string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Define path to test/helper/sample-schema/multimodal/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/multimodal/data"
+		// Define class
+		className := "GoogleClipTest"
+		class := multimodal.BaseClass(className, true)
+		class.VectorConfig = map[string]models.VectorConfig{
+			"clip_google": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"imageFields":        []interface{}{multimodal.PropertyImage},
+						"vectorizeClassName": false,
+						"location":           location,
+						"projectId":          gcpProject,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			"clip_google_128": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"imageFields":        []interface{}{multimodal.PropertyImage},
+						"vectorizeClassName": false,
+						"location":           location,
+						"projectId":          gcpProject,
+						"dimensions":         128,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			"clip_google_256": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"imageFields":        []interface{}{multimodal.PropertyImage},
+						"vectorizeClassName": false,
+						"location":           location,
+						"projectId":          gcpProject,
+						"dimensions":         256,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			"clip_google_video": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"videoFields":        []interface{}{multimodal.PropertyVideo},
+						"vectorizeClassName": false,
+						"location":           location,
+						"projectId":          gcpProject,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			"clip_google_weights": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"textFields":  []interface{}{multimodal.PropertyImageTitle, multimodal.PropertyImageDescription},
+						"imageFields": []interface{}{multimodal.PropertyImage},
+						"weights": map[string]interface{}{
+							"textFields":  []interface{}{0.05, 0.05},
+							"imageFields": []interface{}{0.9},
+						},
+						"vectorizeClassName": false,
+						"location":           location,
+						"projectId":          gcpProject,
+						"dimensions":         512,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		// create schema
+		helper.CreateClass(t, class)
+		defer helper.DeleteClass(t, class.Class)
+
+		t.Run("import data", func(t *testing.T) {
+			multimodal.InsertObjects(t, dataFolderPath, class.Class, true)
+		})
+
+		t.Run("check objects", func(t *testing.T) {
+			vectorNames := []string{"clip_google", "clip_google_128", "clip_google_256", "clip_google_video", "clip_google_weights"}
+			multimodal.CheckObjects(t, dataFolderPath, class.Class, vectorNames, nil)
+		})
+
+		t.Run("nearImage", func(t *testing.T) {
+			blob, err := multimodal.GetImageBlob(dataFolderPath, 2)
+			require.NoError(t, err)
+			targetVector := "clip_google"
+			nearMediaArgument := fmt.Sprintf(`
+				nearImage: {
+					image: "%s"
+					targetVectors: ["%s"]
+				}
+			`, blob, targetVector)
+			titleProperty := multimodal.PropertyImageTitle
+			titlePropertyValue := "waterfalls"
+			targetVectors := map[string]int{
+				"clip_google":         1408,
+				"clip_google_128":     128,
+				"clip_google_256":     256,
+				"clip_google_video":   1408,
+				"clip_google_weights": 512,
+			}
+			multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, targetVectors)
+		})
+
+		t.Run("nearVideo", func(t *testing.T) {
+			blob, err := multimodal.GetVideoBlob(dataFolderPath, 2)
+			require.NoError(t, err)
+			targetVector := "clip_google_video"
+			nearMediaArgument := fmt.Sprintf(`
+				nearVideo: {
+					video: "%s"
+					targetVectors: ["%s"]
+				}
+			`, blob, targetVector)
+			titleProperty := multimodal.PropertyVideoTitle
+			titlePropertyValue := "dog"
+			targetVectors := map[string]int{
+				"clip_google":         1408,
+				"clip_google_128":     128,
+				"clip_google_256":     256,
+				"clip_google_video":   1408,
+				"clip_google_weights": 512,
+			}
+			multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, targetVectors)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-google/setup_test.go

@@ -0,0 +1,60 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+const (
+	location = "us-central1"
+)
+
+func TestMulti2VecGoogle_SingleNode(t *testing.T) {
+	gcpProject := os.Getenv("GCP_PROJECT")
+	if gcpProject == "" {
+		t.Skip("skipping, GCP_PROJECT environment variable not present")
+	}
+	googleApiKey := os.Getenv("GOOGLE_APIKEY")
+	if googleApiKey == "" {
+		t.Skip("skipping, GOOGLE_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, googleApiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("multi2vec-google", testMulti2VecGoogle(endpoint, gcpProject, location, "multi2vec-google"))
+	t.Run("multi2vec-palm", testMulti2VecGoogle(endpoint, gcpProject, location, "multi2vec-palm"))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, googleApiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(googleApiKey).
+		WithWeaviate().
+		Start(ctx)
+	return
+}
+
+func composeModules(googleApiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithMulti2VecGoogle(googleApiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-jinaai/multi2vec_jinaai_test.go

@@ -0,0 +1,124 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multimodal"
+)
+
+func testMulti2VecJinaAI(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Define path to test/helper/sample-schema/multimodal/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/multimodal/data"
+		tests := []struct {
+			name                  string
+			model                 string
+			clipWeightsDimensions int
+		}{
+			{
+				name: "default settings",
+			},
+			{
+				name:                  "jina-embeddings-v4",
+				model:                 "jina-embeddings-v4",
+				clipWeightsDimensions: 2048,
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				// Define settings
+				clipSettings := map[string]interface{}{
+					"imageFields":        []interface{}{multimodal.PropertyImage},
+					"vectorizeClassName": false,
+					"dimensions":         600,
+				}
+				if tt.model != "" {
+					clipSettings["model"] = tt.model
+				}
+				clipWeightsSettings := map[string]interface{}{
+					"textFields":  []interface{}{multimodal.PropertyImageTitle, multimodal.PropertyImageDescription},
+					"imageFields": []interface{}{multimodal.PropertyImage},
+					"weights": map[string]interface{}{
+						"textFields":  []interface{}{0.05, 0.05},
+						"imageFields": []interface{}{0.9},
+					},
+					"vectorizeClassName": false,
+				}
+				if tt.model != "" {
+					clipWeightsSettings["model"] = tt.model
+				}
+				if tt.clipWeightsDimensions > 0 {
+					clipWeightsSettings["dimensions"] = tt.clipWeightsDimensions
+				}
+				// Define class
+				vectorizerName := "multi2vec-jinaai"
+				className := "ClipTest"
+				class := multimodal.BaseClass(className, false)
+				class.VectorConfig = map[string]models.VectorConfig{
+					"clip": {
+						Vectorizer: map[string]interface{}{
+							vectorizerName: clipSettings,
+						},
+						VectorIndexType: "flat",
+					},
+					"clip_weights": {
+						Vectorizer: map[string]interface{}{
+							vectorizerName: clipWeightsSettings,
+						},
+						VectorIndexType: "flat",
+					},
+				}
+				// create schema
+				helper.CreateClass(t, class)
+				defer helper.DeleteClass(t, class.Class)
+
+				t.Run("import data", func(t *testing.T) {
+					multimodal.InsertObjects(t, dataFolderPath, class.Class, false)
+				})
+
+				t.Run("check objects", func(t *testing.T) {
+					multimodal.CheckObjects(t, dataFolderPath, class.Class, []string{"clip", "clip_weights"}, nil)
+				})
+
+				t.Run("nearImage", func(t *testing.T) {
+					blob, err := multimodal.GetImageBlob(dataFolderPath, 2)
+					require.NoError(t, err)
+					targetVector := "clip"
+					nearMediaArgument := fmt.Sprintf(`
+						nearImage: {
+							image: "%s"
+							targetVectors: ["%s"]
+						}
+					`, blob, targetVector)
+					titleProperty := multimodal.PropertyImageTitle
+					titlePropertyValue := "waterfalls"
+					clipWeightsDimensions := 1024
+					if tt.clipWeightsDimensions > 0 {
+						clipWeightsDimensions = tt.clipWeightsDimensions
+					}
+					targetVectors := map[string]int{
+						"clip":         600,
+						"clip_weights": clipWeightsDimensions,
+					}
+					multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, targetVectors)
+				})
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-jinaai/setup_test.go

@@ -0,0 +1,43 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multimodal"
+)
+
+func TestMulti2VecJinaAI_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("JINAAI_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, JINAAI_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviate().
+		WithMulti2VecJinaAI(apiKey).
+		WithWeaviateEnv("MODULES_CLIENT_TIMEOUT", fmt.Sprintf("%.0fs", multimodal.DefaultTimeout.Seconds())).
+		Start(ctx)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("multi2vec-jinaai", testMulti2VecJinaAI(endpoint))
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-nvidia/multi2vec_nvidia_test.go

@@ -0,0 +1,86 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multimodal"
+)
+
+func testMulti2VecNvidia(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Define path to test/helper/sample-schema/multimodal/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/multimodal/data"
+		// Define class
+		vectorizerName := "multi2vec-nvidia"
+		className := "NvidiaClipTest"
+		class := multimodal.BaseClass(className, false)
+		class.VectorConfig = map[string]models.VectorConfig{
+			"clip": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"imageFields":        []interface{}{multimodal.PropertyImage},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			"clip_weights": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"model":       "nvidia/nvclip",
+						"textFields":  []interface{}{multimodal.PropertyImageTitle, multimodal.PropertyImageDescription},
+						"imageFields": []interface{}{multimodal.PropertyImage},
+						"weights": map[string]interface{}{
+							"textFields":  []interface{}{0.05, 0.05},
+							"imageFields": []interface{}{0.9},
+						},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		// create schema
+		helper.CreateClass(t, class)
+		defer helper.DeleteClass(t, class.Class)
+
+		t.Run("import data", func(t *testing.T) {
+			multimodal.InsertObjects(t, dataFolderPath, class.Class, false)
+		})
+
+		t.Run("nearImage", func(t *testing.T) {
+			blob, err := multimodal.GetImageBlob(dataFolderPath, 2)
+			require.NoError(t, err)
+			targetVector := "clip"
+			nearMediaArgument := fmt.Sprintf(`
+				nearImage: {
+					image: "%s"
+					targetVectors: ["%s"]
+				}
+			`, blob, targetVector)
+			titleProperty := multimodal.PropertyImageTitle
+			titlePropertyValue := "waterfalls"
+			targetVectors := map[string]int{
+				"clip":         1024,
+				"clip_weights": 1024,
+			}
+			multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, targetVectors)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-nvidia/setup_test.go

@@ -0,0 +1,51 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestMulti2VecNvidia(t *testing.T) {
+	apiKey := os.Getenv("NVIDIA_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, NVIDIA_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("multi2vec-nvidia", testMulti2VecNvidia(endpoint))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey).
+		WithWeaviate().
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithMulti2VecNvidia(apiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-voyageai/multi2vec_voyageai_test.go

@@ -0,0 +1,86 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/multimodal"
+)
+
+func testMulti2VecVoyageAI(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		helper.SetupClient(host)
+		// Define path to test/helper/sample-schema/multimodal/data folder
+		dataFolderPath := "../../../test/helper/sample-schema/multimodal/data"
+		// Define class
+		vectorizerName := "multi2vec-voyageai"
+		className := "VoyageAIClipTest"
+		class := multimodal.BaseClass(className, false)
+		class.VectorConfig = map[string]models.VectorConfig{
+			"clip": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"imageFields":        []interface{}{multimodal.PropertyImage},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			"clip_weights": {
+				Vectorizer: map[string]interface{}{
+					vectorizerName: map[string]interface{}{
+						"model":       "voyage-multimodal-3",
+						"textFields":  []interface{}{multimodal.PropertyImageTitle, multimodal.PropertyImageDescription},
+						"imageFields": []interface{}{multimodal.PropertyImage},
+						"weights": map[string]interface{}{
+							"textFields":  []interface{}{0.05, 0.05},
+							"imageFields": []interface{}{0.9},
+						},
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+		}
+		// create schema
+		helper.CreateClass(t, class)
+		defer helper.DeleteClass(t, class.Class)
+
+		t.Run("import data", func(t *testing.T) {
+			multimodal.InsertObjects(t, dataFolderPath, class.Class, false)
+		})
+
+		t.Run("nearImage", func(t *testing.T) {
+			blob, err := multimodal.GetImageBlob(dataFolderPath, 2)
+			require.NoError(t, err)
+			targetVector := "clip"
+			nearMediaArgument := fmt.Sprintf(`
+				nearImage: {
+					image: "%s"
+					targetVectors: ["%s"]
+				}
+			`, blob, targetVector)
+			titleProperty := multimodal.PropertyImageTitle
+			titlePropertyValue := "waterfalls"
+			targetVectors := map[string]int{
+				"clip":         1024,
+				"clip_weights": 1024,
+			}
+			multimodal.TestQuery(t, class.Class, nearMediaArgument, titleProperty, titlePropertyValue, targetVectors)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/modules/multi2vec-voyageai/setup_test.go

@@ -0,0 +1,51 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package tests
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestMulti2VecVoyageAI_SingleNode(t *testing.T) {
+	apiKey := os.Getenv("VOYAGEAI_APIKEY")
+	if apiKey == "" {
+		t.Skip("skipping, VOYAGEAI_APIKEY environment variable not present")
+	}
+	ctx := context.Background()
+	compose, err := createSingleNodeEnvironment(ctx, apiKey)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, compose.Terminate(ctx))
+	}()
+	endpoint := compose.GetWeaviate().URI()
+
+	t.Run("multi2vec-voyageai", testMulti2VecVoyageAI(endpoint))
+}
+
+func createSingleNodeEnvironment(ctx context.Context, apiKey string,
+) (compose *docker.DockerCompose, err error) {
+	compose, err = composeModules(apiKey).
+		WithWeaviate().
+		Start(ctx)
+	return
+}
+
+func composeModules(apiKey string) (composeModules *docker.Compose) {
+	composeModules = docker.New().
+		WithMulti2VecVoyageAI(apiKey)
+	return
+}

platform/dbops/binaries/weaviate-src/test/modules/offload-s3/misocnfigured_test.go

@@ -0,0 +1,197 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"slices"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func Test_DeleteTenantsWhileMisconfigured(t *testing.T) {
+	t.Run("misconfigure offload, create tenant, delete tenant", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+		defer cancel()
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, "the_wrong_Key")
+		t.Setenv(envS3SecretKey, "the_wrong_Key")
+
+		compose, err := docker.New().
+			WithOffloadS3("not-existing-bucket", "us-west-1").
+			WithWeaviateEnv("OFFLOAD_TIMEOUT", "120").
+			WithWeaviateEnv("OFFLOAD_S3_ENDPOINT", "http://test-minio:0000"). // wrong port configured
+			WithoutWeaviateEnvs("OFFLOAD_S3_BUCKET_AUTO_CREATE").
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		defer func() {
+			helper.DeleteClass(t, className)
+		}()
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i], ActivityStatus: models.TenantActivityStatusACTIVE}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		t.Run("delete tenant 1 in time manner", func(t *testing.T) {
+			customCtx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+			defer cancel()
+
+			errChan := make(chan error, 1)
+			go func() {
+				errChan <- helper.DeleteTenantsWithContext(t, customCtx, className, []string{tenantNames[0]})
+			}()
+
+			select {
+			case err := <-errChan:
+				require.NoError(t, err, "got error while expecting none")
+
+			case <-customCtx.Done():
+				require.FailNowf(t, "operation took longer than timeout: %v", customCtx.Err().Error())
+			}
+		})
+
+		t.Run("get tenants after deletion", func(t *testing.T) {
+			response, err := helper.GetTenants(t, className)
+			require.NoError(t, err)
+			returnedTenantsNames := []string{}
+			for _, tn := range response.Payload {
+				returnedTenantsNames = append(returnedTenantsNames, tn.Name)
+			}
+
+			slices.Sort(tenantNames[1:])
+			slices.Sort(returnedTenantsNames)
+			require.Equal(t, tenantNames[1:], returnedTenantsNames, "expected tenant to be deleted but it's not")
+		})
+	})
+}
+
+func Test_DeleteTenantsWhileProviderIsDown(t *testing.T) {
+	t.Run("offload, create tenant, minio down, delete tenant", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+		defer cancel()
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("not-existing-bucket", "us-west-1").
+			WithWeaviateEnv("OFFLOAD_TIMEOUT", "120").
+			WithoutWeaviateEnvs("OFFLOAD_S3_BUCKET_AUTO_CREATE").
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		defer func() {
+			helper.DeleteClass(t, className)
+		}()
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i], ActivityStatus: models.TenantActivityStatusACTIVE}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+		t.Run("stop minio", func(t *testing.T) {
+			require.NoError(t, compose.StopMinIO(ctx))
+		})
+
+		t.Run("delete tenant 1 in time manner", func(t *testing.T) {
+			customCtx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+			defer cancel()
+
+			errChan := make(chan error, 1)
+			go func() {
+				errChan <- helper.DeleteTenantsWithContext(t, customCtx, className, []string{tenantNames[0]})
+			}()
+
+			select {
+			case err := <-errChan:
+				require.NoError(t, err, "got error while expecting none")
+
+			case <-customCtx.Done():
+				require.FailNowf(t, "operation took longer than timeout: %v", customCtx.Err().Error())
+			}
+		})
+
+		t.Run("get tenants after deletion", func(t *testing.T) {
+			response, err := helper.GetTenants(t, className)
+			require.NoError(t, err)
+			returnedTenantsNames := []string{}
+			for _, tn := range response.Payload {
+				returnedTenantsNames = append(returnedTenantsNames, tn.Name)
+			}
+
+			slices.Sort(tenantNames[1:])
+			slices.Sort(returnedTenantsNames)
+			require.Equal(t, tenantNames[1:], returnedTenantsNames, "expected tenant to be deleted but it's not")
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/offload-s3/offlad_delete_test.go

@@ -0,0 +1,409 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/cluster/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func Test_DeleteClassS3Journey(t *testing.T) {
+	t.Run("delete class, deleting frozen tenants", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("offloading", "us-west-1").
+			WithText2VecContextionary().
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+		}
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[0])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("verify created objects length", func(t *testing.T) {
+			resp, err := helper.TenantListObjects(t, className, tenantNames[0])
+			require.Nil(t, err)
+			assert.Equal(t, len(tenantObjects), len(resp.Objects))
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status FREEZING", func(t *testing.T) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				if tn.Name == tenantNames[0] {
+					require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+					break
+				}
+			}
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			_, err = helper.TenantObject(t, tenantObjects[0].Class, tenantObjects[0].ID, tenantNames[0])
+			require.NotNil(t, err)
+		})
+
+		t.Run("verify tenant status", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+		})
+
+		t.Run("verify deleting class", func(t *testing.T) {
+			helper.DeleteClass(t, className)
+		})
+
+		t.Run("verify frozen tenants deleted from cloud", func(t *testing.T) {
+			client, err := minio.New(compose.GetMinIO().URI(), &minio.Options{
+				Creds:  credentials.NewEnvAWS(),
+				Secure: false,
+			})
+			require.Nil(t, err)
+
+			count := 0
+			for obj := range client.ListObjects(ctx, "offloading", minio.ListObjectsOptions{Prefix: strings.ToLower(className)}) {
+				if obj.Key != "" {
+					count++
+					t.Log(obj.Key)
+				}
+			}
+			require.Nil(t, err)
+			require.Zero(t, count)
+		})
+	})
+}
+
+func Test_DeleteAndRecreateS3Journey(t *testing.T) {
+	t.Run("create tenant, freeze, delete, re-create", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("offloading", "us-west-1").
+			WithText2VecContextionary().
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+		}
+
+		defer func() {
+			helper.DeleteClass(t, className)
+		}()
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[0])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("verify created objects length", func(t *testing.T) {
+			resp, err := helper.TenantListObjects(t, className, tenantNames[0])
+			require.Nil(t, err)
+			assert.Equal(t, len(tenantObjects), len(resp.Objects))
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status FREEZING", func(t *testing.T) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				if tn.Name == tenantNames[0] {
+					require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+					break
+				}
+			}
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			_, err = helper.TenantObject(t, tenantObjects[0].Class, tenantObjects[0].ID, tenantNames[0])
+			require.NotNil(t, err)
+		})
+
+		t.Run("verify tenant status", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+		})
+
+		t.Run("delete tenant", func(t *testing.T) {
+			err := helper.DeleteTenants(t, className, []string{tenantNames[0]})
+			require.Nil(t, err)
+		})
+
+		t.Run("create tenant", func(t *testing.T) {
+			helper.CreateTenants(t, className, []*models.Tenant{{Name: tenantNames[0]}})
+		})
+
+		t.Run("add tenant 1 object", func(t *testing.T) {
+			assert.Nil(t, helper.CreateObject(t, tenantObjects[0]))
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			resp, err := helper.TenantObject(t, tenantObjects[0].Class, tenantObjects[0].ID, tenantNames[0])
+			require.Nil(t, err)
+			assert.Equal(t, tenantObjects[0].Class, resp.Class)
+			assert.Equal(t, tenantObjects[0].Properties, resp.Properties)
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status is FROZEN", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusHOT,
+				},
+			})
+		})
+
+		t.Run("verify tenant status is HOT", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, models.TenantActivityStatusHOT, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusHOT))
+		})
+
+		t.Run("verify created object", func(t *testing.T) {
+			resp, err := helper.TenantListObjects(t, className, tenantNames[0])
+			require.Nil(t, err)
+			assert.Equal(t, 1, len(resp.Objects))
+			assert.Equal(t, tenantObjects[0].Class, resp.Objects[0].Class)
+			assert.Equal(t, tenantObjects[0].Properties, resp.Objects[0].Properties)
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/offload-s3/offload_bucket_test.go

@@ -0,0 +1,201 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/cluster/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func Test_OffloadBucketNotAutoCreate(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+
+	t.Log("pre-instance env setup")
+	t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+	t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+	compose, err := docker.New().
+		WithOffloadS3("offloading", "us-west-1").
+		WithText2VecContextionary().
+		WithWeaviateEnv("OFFLOAD_TIMEOUT", "1").
+		WithoutWeaviateEnvs("OFFLOAD_S3_BUCKET_AUTO_CREATE").
+		WithWeaviate().
+		Start(ctx)
+	require.Nil(t, err)
+
+	if err := compose.Terminate(ctx); err != nil {
+		t.Fatalf("failed to terminate test containers: %s", err.Error())
+	}
+}
+
+func Test_OffloadBucketNotAutoCreateMinioManualCreate(t *testing.T) {
+	t.Run("success because created manually in minio", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+		bucketname := "offloading"
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3(bucketname, "us-west-1").
+			WithText2VecContextionary().
+			WithWeaviateEnv("OFFLOAD_S3_BUCKET_AUTO_CREATE", "false").
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+		}
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status FREEZING", func(t *testing.T) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				if tn.Name == tenantNames[0] {
+					require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+					break
+				}
+			}
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			_, err = helper.TenantObject(t, tenantObjects[0].Class, tenantObjects[0].ID, tenantNames[0])
+			require.NotNil(t, err)
+		})
+
+		t.Run("verify tenant status", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+		})
+
+		t.Run("verify deleting class", func(t *testing.T) {
+			helper.DeleteClass(t, className)
+		})
+
+		t.Run("verify frozen tenants deleted from cloud", func(t *testing.T) {
+			client, err := minio.New(compose.GetMinIO().URI(), &minio.Options{
+				Creds:  credentials.NewEnvAWS(),
+				Secure: false,
+			})
+			require.Nil(t, err)
+
+			count := 0
+			for obj := range client.ListObjects(ctx, "offloading", minio.ListObjectsOptions{Prefix: strings.ToLower(className)}) {
+				if obj.Key != "" {
+					count++
+					t.Log(obj.Key)
+				}
+			}
+			require.Nil(t, err)
+			require.Zero(t, count)
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/offload-s3/offload_download_test.go

@@ -0,0 +1,354 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	pb "github.com/weaviate/weaviate/grpc/generated/protocol/v1"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func Test_DownloadS3Journey(t *testing.T) {
+	t.Run("happy path with RF 2 download from s3 provider, HOT status", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("offloading", "us-west-1").
+			WithText2VecContextionary().
+			WithWeaviateClusterWithGRPC().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.SetupGRPCClient(t, compose.GetWeaviate().GrpcURI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[1],
+				},
+				Tenant: tenantNames[1],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[2],
+				},
+				Tenant: tenantNames[2],
+			},
+		}
+
+		defer func() {
+			helper.DeleteClass(t, className)
+		}()
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for i, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenantsGRPC(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Tenants {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_FROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_FROZEN))
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			_, err = helper.TenantObject(t, tenantObjects[0].Class, tenantObjects[0].ID, tenantNames[0])
+			require.NotNil(t, err)
+		})
+
+		t.Run("updating tenant status to HOT", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusHOT,
+				},
+			})
+		})
+
+		t.Run("verify tenant status HOT", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenantsGRPC(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Tenants {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_HOT, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_HOT))
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for i, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+	})
+
+	t.Run("happy path with RF 2 download from s3 provider COLD status", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("offloading", "us-west-1").
+			WithText2VecContextionary().
+			WithWeaviateClusterWithGRPC().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.SetupGRPCClient(t, compose.GetWeaviate().GrpcURI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[1],
+				},
+				Tenant: tenantNames[1],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[2],
+				},
+				Tenant: tenantNames[2],
+			},
+		}
+
+		defer func() {
+			helper.DeleteClass(t, className)
+		}()
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for i, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("updating tenant status to COLD", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				},
+			})
+		})
+
+		t.Run("verify tenant status COLD", func(t *testing.T) {
+			resp, err := helper.GetTenantsGRPC(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Tenants {
+				if tn.Name == tenantNames[0] {
+					require.Equal(t, pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_COLD, tn.ActivityStatus)
+					break
+				}
+			}
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenantsGRPC(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Tenants {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_FROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_FROZEN))
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			_, err = helper.TenantObject(t, tenantObjects[0].Class, tenantObjects[0].ID, tenantNames[0])
+			require.NotNil(t, err)
+		})
+
+		t.Run("updating tenant status to COLD", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusCOLD,
+				},
+			})
+		})
+
+		t.Run("verify tenant status COLD", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenantsGRPC(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Tenants {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_COLD, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", pb.TenantActivityStatus_TENANT_ACTIVITY_STATUS_COLD))
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/offload-s3/offload_not_enabled_test.go

@@ -0,0 +1,116 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	client "github.com/weaviate/weaviate/client/schema"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func Test_Offload_When_Not_Enabled(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	compose, err := docker.New().
+		WithText2VecContextionary().
+		With3NodeCluster().
+		Start(ctx)
+	require.Nil(t, err)
+
+	defer func() {
+		if err := compose.Terminate(ctx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+
+	className := "MultiTenantClass"
+	testClass := models.Class{
+		Class:             className,
+		ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+		MultiTenancyConfig: &models.MultiTenancyConfig{
+			Enabled: true,
+		},
+		Properties: []*models.Property{
+			{
+				Name:     "name",
+				DataType: schema.DataTypeText.PropString(),
+			},
+		},
+	}
+	t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+		helper.CreateClass(t, &testClass)
+	})
+
+	tenantNames := []string{
+		"Tenant1", "Tenant2", "Tenant3",
+	}
+	tenants := make([]*models.Tenant, len(tenantNames))
+
+	t.Run("create tenants", func(t *testing.T) {
+		for i := range tenants {
+			tenants[i] = &models.Tenant{Name: tenantNames[i]}
+		}
+		helper.CreateTenants(t, className, tenants)
+	})
+
+	tenantObjects := make([]*models.Object, len(tenantNames))
+	for i := range tenantObjects {
+		tenantObjects[i] = &models.Object{
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[0],
+			},
+			Tenant: tenantNames[0],
+		}
+	}
+
+	defer func() {
+		helper.DeleteClass(t, className)
+	}()
+
+	t.Run("add tenant objects", func(t *testing.T) {
+		for _, obj := range tenantObjects {
+			assert.Nil(t, helper.CreateObject(t, obj))
+		}
+	})
+
+	t.Run("updating tenant status", func(t *testing.T) {
+		t.Helper()
+		for i := range tenants {
+			tenants[i].ActivityStatus = "FROZEN"
+		}
+		params := client.NewTenantsUpdateParams().
+			WithClassName(className).WithBody(tenants)
+		_, err := helper.Client(t).Schema.TenantsUpdate(params, nil)
+		require.NotNil(t, err)
+
+		tenantErr := &client.TenantsUpdateUnprocessableEntity{}
+		if !errors.As(err, &tenantErr) {
+			t.Fatalf("expected %T, got: %T", tenantErr, err)
+		}
+		require.NotNil(t, tenantErr.Payload)
+		require.Len(t, tenantErr.Payload.Error, 1)
+		msg := tenantErr.Payload.Error[0].Message
+		assert.Equal(t, "can't offload tenants, because offload-s3 module is not enabled", msg)
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/offload-s3/offload_test.go

@@ -0,0 +1,618 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/objects"
+	"github.com/weaviate/weaviate/cluster/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+const (
+	envS3AccessKey           = "AWS_ACCESS_KEY_ID"
+	envS3SecretKey           = "AWS_SECRET_KEY"
+	s3BackupJourneyAccessKey = "aws_access_key"
+	s3BackupJourneySecretKey = "aws_secret_key"
+)
+
+func Test_Upload_DownloadS3Journey(t *testing.T) {
+	t.Run("happy path with RF 2 upload to s3 provider", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("offloading", "us-west-1").
+			WithText2VecContextionary().
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[1],
+				},
+				Tenant: tenantNames[1],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[2],
+				},
+				Tenant: tenantNames[2],
+			},
+		}
+
+		defer func() {
+			helper.DeleteClass(t, className)
+		}()
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for i, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			tenants := []*models.Tenant{}
+			for i := range tenantNames {
+				tenants = append(tenants, &models.Tenant{
+					Name:           tenantNames[i],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				})
+			}
+
+			helper.UpdateTenants(t, className, tenants)
+		})
+
+		t.Run("verify tenant status FREEZING", func(t *testing.T) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				for i := range tenantNames {
+					if tn.Name == tenantNames[i] {
+						require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+						break
+					}
+				}
+			}
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			for i := range tenantObjects {
+				_, err = helper.TenantObject(t, tenantObjects[i].Class, tenantObjects[i].ID, tenantNames[i])
+				require.NotNil(t, err)
+			}
+		})
+
+		t.Run("verify tenant status", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					for i := range tenantNames {
+						if tn.Name == tenantNames[i] {
+							assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+							break
+						}
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+		})
+
+		t.Run("updating tenant status to HOT", func(t *testing.T) {
+			tenants := []*models.Tenant{}
+			for i := range tenantNames {
+				tenants = append(tenants, &models.Tenant{
+					Name:           tenantNames[i],
+					ActivityStatus: models.TenantActivityStatusHOT,
+				})
+			}
+
+			helper.UpdateTenants(t, className, tenants)
+		})
+
+		t.Run("verify tenant status HOT", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					for i := range tenantNames {
+						if tn.Name == tenantNames[i] {
+							assert.Equal(at, models.TenantActivityStatusHOT, tn.ActivityStatus)
+							break
+						}
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusHOT))
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for i, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			tenants := []*models.Tenant{}
+			for i := range tenantNames {
+				tenants = append(tenants, &models.Tenant{
+					Name:           tenantNames[i],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				})
+			}
+
+			helper.UpdateTenants(t, className, tenants)
+		})
+
+		t.Run("verify tenant status FREEZING", func(t *testing.T) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				for i := range tenantNames {
+					if tn.Name == tenantNames[i] {
+						require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+						break
+					}
+				}
+			}
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			for i := range tenantObjects {
+				_, err = helper.TenantObject(t, tenantObjects[i].Class, tenantObjects[i].ID, tenantNames[i])
+				require.NotNil(t, err)
+			}
+		})
+	})
+}
+
+func Test_AutoTenantActivation(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	t.Log("pre-instance env setup")
+	t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+	t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+	compose, err := docker.New().
+		WithOffloadS3("offloading", "us-west-1").
+		WithText2VecContextionary().
+		With3NodeCluster().
+		Start(ctx)
+	require.Nil(t, err)
+
+	defer func() {
+		if err := compose.Terminate(ctx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+
+	className := "MultiTenantClass"
+	testClass := models.Class{
+		Class:             className,
+		ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+		MultiTenancyConfig: &models.MultiTenancyConfig{
+			Enabled:              true,
+			AutoTenantActivation: true,
+		},
+		Properties: []*models.Property{
+			{
+				Name:     "name",
+				DataType: schema.DataTypeText.PropString(),
+			},
+		},
+	}
+	t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+		helper.CreateClass(t, &testClass)
+	})
+
+	tenantNames := []string{
+		"Tenant1", "Tenant2", "Tenant3",
+	}
+	t.Run("create tenants", func(t *testing.T) {
+		tenants := make([]*models.Tenant, len(tenantNames))
+		for i := range tenants {
+			tenants[i] = &models.Tenant{Name: tenantNames[i]}
+		}
+		helper.CreateTenants(t, className, tenants)
+	})
+
+	tenantObjects := []*models.Object{
+		{
+			ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[0],
+			},
+			Tenant: tenantNames[0],
+		},
+		{
+			ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[1],
+			},
+			Tenant: tenantNames[1],
+		},
+		{
+			ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[2],
+			},
+			Tenant: tenantNames[2],
+		},
+	}
+
+	defer func() {
+		helper.DeleteClass(t, className)
+	}()
+
+	t.Run("add tenant objects", func(t *testing.T) {
+		for _, obj := range tenantObjects {
+			assert.Nil(t, helper.CreateObject(t, obj))
+		}
+	})
+
+	t.Run("verify object creation", func(t *testing.T) {
+		for i, obj := range tenantObjects {
+			resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+			require.Nil(t, err)
+			assert.Equal(t, obj.Class, resp.Class)
+			assert.Equal(t, obj.Properties, resp.Properties)
+		}
+	})
+
+	t.Run("updating tenant status", func(t *testing.T) {
+		tenants := []*models.Tenant{}
+		for i := range tenantNames {
+			tenants = append(tenants, &models.Tenant{
+				Name:           tenantNames[i],
+				ActivityStatus: models.TenantActivityStatusFROZEN,
+			})
+		}
+
+		helper.UpdateTenants(t, className, tenants)
+	})
+
+	t.Run("verify tenant status FREEZING", func(t *testing.T) {
+		resp, err := helper.GetTenants(t, className)
+		require.Nil(t, err)
+		for _, tn := range resp.Payload {
+			for i := range tenantNames {
+				if tn.Name == tenantNames[i] {
+					require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+					break
+				}
+			}
+		}
+	})
+
+	t.Run("verify tenant status", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(at *assert.CollectT) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				for i := range tenantNames {
+					if tn.Name == tenantNames[i] {
+						assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}
+		}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+	})
+
+	objectsToCreate := []*models.Object{
+		{
+			ID:    strfmt.UUID(uuid.NewString()),
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[0],
+			},
+			Tenant: tenantNames[0],
+		},
+		{
+			ID:    strfmt.UUID(uuid.NewString()),
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[1],
+			},
+			Tenant: tenantNames[1],
+		},
+		{
+			ID:    strfmt.UUID(uuid.NewString()),
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[2],
+			},
+			Tenant: tenantNames[2],
+		},
+		{
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[0],
+			},
+			Tenant: tenantNames[0],
+		},
+	}
+
+	t.Run("add tenant objects", func(t *testing.T) {
+		for i, obj := range objectsToCreate {
+			res, err := helper.CreateObjectWithResponse(t, obj)
+			if err != nil {
+				oe := &objects.ObjectsCreateUnprocessableEntity{}
+				as := errors.As(err, &oe)
+				require.True(t, as)
+				t.Log(oe.Payload.Error[0])
+				t.Log(oe.Error())
+				t.Log(oe.Payload)
+			}
+			require.Nil(t, err)
+
+			if obj.ID == "" {
+				// Some of the test objects were created without ID
+				objectsToCreate[i].ID = res.ID
+			}
+		}
+	})
+
+	t.Run("verify object creation", func(t *testing.T) {
+		for _, obj := range objectsToCreate {
+			resp, err := helper.TenantObject(t, obj.Class, obj.ID, obj.Tenant)
+			require.Nil(t, err)
+			assert.Equal(t, obj.Class, resp.Class)
+			assert.Equal(t, obj.Properties, resp.Properties)
+		}
+	})
+}
+
+func Test_ConcurrentFreezeUnfreeze(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	t.Log("pre-instance env setup")
+	t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+	t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+	compose, err := docker.New().
+		WithOffloadS3("offloading", "us-west-1").
+		WithText2VecContextionary().
+		With3NodeCluster().
+		Start(ctx)
+	require.Nil(t, err)
+
+	defer func() {
+		if err := compose.Terminate(ctx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+
+	className := "MultiTenantClass"
+	testClass := models.Class{
+		Class:             className,
+		ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+		MultiTenancyConfig: &models.MultiTenancyConfig{
+			Enabled: true,
+		},
+		Properties: []*models.Property{
+			{
+				Name:     "name",
+				DataType: schema.DataTypeText.PropString(),
+			},
+		},
+	}
+	t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+		helper.CreateClass(t, &testClass)
+	})
+
+	defer func() {
+		helper.DeleteClass(t, className)
+	}()
+
+	tenantNames := []string{
+		"Tenant1", "Tenant2", "Tenant3",
+	}
+	t.Run("create tenants", func(t *testing.T) {
+		tenants := make([]*models.Tenant, len(tenantNames))
+		for i := range tenants {
+			tenants[i] = &models.Tenant{Name: tenantNames[i]}
+		}
+		helper.CreateTenants(t, className, tenants)
+	})
+
+	tenantObjects := []*models.Object{
+		{
+			ID:    strfmt.UUID(uuid.NewString()),
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[0],
+			},
+			Tenant: tenantNames[0],
+		},
+		{
+			ID:    strfmt.UUID(uuid.NewString()),
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[1],
+			},
+			Tenant: tenantNames[1],
+		},
+		{
+			ID:    strfmt.UUID(uuid.NewString()),
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": tenantNames[2],
+			},
+			Tenant: tenantNames[2],
+		},
+	}
+
+	t.Run("add tenant objects", func(t *testing.T) {
+		for _, obj := range tenantObjects {
+			assert.Nil(t, helper.CreateObject(t, obj))
+		}
+	})
+
+	t.Run("verify object creation", func(t *testing.T) {
+		for i, obj := range tenantObjects {
+			resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+			require.Nil(t, err)
+			assert.Equal(t, obj.Class, resp.Class)
+			assert.Equal(t, obj.Properties, resp.Properties)
+		}
+	})
+
+	t.Run("updating tenant status", func(t *testing.T) {
+		tenants := []*models.Tenant{}
+		for i := range tenantNames {
+			tenants = append(tenants, &models.Tenant{
+				Name:           tenantNames[i],
+				ActivityStatus: models.TenantActivityStatusFROZEN,
+			})
+		}
+
+		for idx := 0; idx < 5; idx++ {
+			go helper.UpdateTenants(t, className, tenants)
+		}
+	})
+
+	t.Run("verify tenant status", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(at *assert.CollectT) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				for i := range tenantNames {
+					if tn.Name == tenantNames[i] {
+						assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}
+		}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+	})
+
+	t.Run("verify tenant does not exists", func(t *testing.T) {
+		for i := range tenantObjects {
+			_, err = helper.TenantObject(t, tenantObjects[i].Class, tenantObjects[i].ID, tenantNames[i])
+			require.NotNil(t, err)
+		}
+	})
+
+	t.Run("updating tenant status to HOT", func(t *testing.T) {
+		tenants := []*models.Tenant{}
+		for i := range tenantNames {
+			tenants = append(tenants, &models.Tenant{
+				Name:           tenantNames[i],
+				ActivityStatus: models.TenantActivityStatusHOT,
+			})
+		}
+
+		for idx := 0; idx < 5; idx++ {
+			go helper.UpdateTenants(t, className, tenants)
+		}
+	})
+
+	t.Run("verify tenant status HOT", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(at *assert.CollectT) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				for i := range tenantNames {
+					if tn.Name == tenantNames[i] {
+						assert.Equal(at, models.TenantActivityStatusHOT, tn.ActivityStatus)
+						break
+					}
+				}
+			}
+		}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusHOT))
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/offload-s3/offload_upload_test.go

@@ -0,0 +1,475 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/objects"
+	"github.com/weaviate/weaviate/cluster/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func Test_UploadS3Journey(t *testing.T) {
+	t.Run("happy path with RF 2 upload to s3 provider", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("offloading", "us-west-1").
+			WithText2VecContextionary().
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 2},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[1],
+				},
+				Tenant: tenantNames[1],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[2],
+				},
+				Tenant: tenantNames[2],
+			},
+		}
+
+		defer func() {
+			helper.DeleteClass(t, className)
+		}()
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for i, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status FREEZING", func(t *testing.T) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+			for _, tn := range resp.Payload {
+				if tn.Name == tenantNames[0] {
+					require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+					break
+				}
+			}
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			_, err = helper.TenantObject(t, tenantObjects[0].Class, tenantObjects[0].ID, tenantNames[0])
+			require.NotNil(t, err)
+		})
+
+		t.Run("verify tenant status", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+		})
+
+		t.Run("add objects to frozen tenant shall fail", func(t *testing.T) {
+			t.Run("add frozen tenant objects", func(t *testing.T) {
+				for _, obj := range tenantObjects {
+					obj.Tenant = tenantNames[0]
+					params := objects.NewObjectsCreateParams().WithBody(obj)
+					_, err := helper.Client(t).Objects.ObjectsCreate(params, nil)
+					require.NotNil(t, err)
+				}
+			})
+
+			tenantRefs := []*models.Object{
+				{
+					ID:    "169b62a7-ef1c-481d-8fb0-27f11716bde7",
+					Class: className,
+					Properties: map[string]interface{}{
+						"name":        tenantNames[0],
+						"mutableProp": "ref#0",
+					},
+					Tenant: tenantNames[0],
+				},
+			}
+
+			t.Run("add frozen tenant object references", func(t *testing.T) {
+				for i, obj := range tenantObjects {
+					ref := &models.SingleRef{Beacon: helper.NewBeacon(className, tenantRefs[0].ID)}
+					params := objects.NewObjectsClassReferencesCreateParams().
+						WithClassName(className).WithID(obj.ID).WithBody(ref).WithPropertyName("refProp").WithTenant(&tenantNames[i])
+					_, err := helper.Client(t).Objects.ObjectsClassReferencesCreate(params, nil)
+					require.NotNil(t, err)
+				}
+			})
+		})
+	})
+
+	t.Run("node is down while RF is 3, one weaviate node is down", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("weaviate-offload", "us-west-1").
+			WithText2VecContextionary().
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 3},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[1],
+				},
+				Tenant: tenantNames[1],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[2],
+				},
+				Tenant: tenantNames[2],
+			},
+		}
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for i, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("StopNode-2", func(t *testing.T) {
+			require.Nil(t, compose.Stop(ctx, compose.GetWeaviateNode2().Name(), nil))
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status FREEZING", func(t *testing.T) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+
+			for _, tn := range resp.Payload {
+				if tn.Name == tenantNames[0] {
+					require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+					break
+				}
+			}
+		})
+
+		t.Run("StartNode-2", func(t *testing.T) {
+			require.Nil(t, compose.Start(ctx, compose.GetWeaviateNode2().Name()))
+		})
+
+		t.Run("verify tenant does not exists", func(t *testing.T) {
+			_, err = helper.TenantObject(t, tenantObjects[0].Class, tenantObjects[0].ID, tenantNames[0])
+			require.NotNil(t, err)
+		})
+
+		t.Run("verify tenant status", func(t *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(t, className)
+				require.Nil(t, err)
+				for _, tn := range resp.Payload {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, models.TenantActivityStatusFROZEN, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusFROZEN))
+		})
+	})
+
+	t.Run("unhappy path with RF 3, cloud provider is down", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+
+		t.Log("pre-instance env setup")
+		t.Setenv(envS3AccessKey, s3BackupJourneyAccessKey)
+		t.Setenv(envS3SecretKey, s3BackupJourneySecretKey)
+
+		compose, err := docker.New().
+			WithOffloadS3("offloading", "us-west-1").
+			WithWeaviateEnv("OFFLOAD_TIMEOUT", "2").
+			WithText2VecContextionary().
+			With3NodeCluster().
+			Start(ctx)
+		require.Nil(t, err)
+
+		defer func() {
+			if err := compose.Terminate(ctx); err != nil {
+				t.Fatalf("failed to terminate test containers: %s", err.Error())
+			}
+		}()
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+
+		className := "MultiTenantClass"
+		testClass := models.Class{
+			Class:             className,
+			ReplicationConfig: &models.ReplicationConfig{Factor: 3},
+			MultiTenancyConfig: &models.MultiTenancyConfig{
+				Enabled: true,
+			},
+			Properties: []*models.Property{
+				{
+					Name:     "name",
+					DataType: schema.DataTypeText.PropString(),
+				},
+			},
+		}
+		t.Run("create class with multi-tenancy enabled", func(t *testing.T) {
+			helper.CreateClass(t, &testClass)
+		})
+
+		tenantNames := []string{
+			"Tenant1", "Tenant2", "Tenant3",
+		}
+		t.Run("create tenants", func(t *testing.T) {
+			tenants := make([]*models.Tenant, len(tenantNames))
+			for i := range tenants {
+				tenants[i] = &models.Tenant{Name: tenantNames[i]}
+			}
+			helper.CreateTenants(t, className, tenants)
+		})
+
+		tenantObjects := []*models.Object{
+			{
+				ID:    "0927a1e0-398e-4e76-91fb-04a7a8f0405c",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[0],
+				},
+				Tenant: tenantNames[0],
+			},
+			{
+				ID:    "831ae1d0-f441-44b1-bb2a-46548048e26f",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[1],
+				},
+				Tenant: tenantNames[1],
+			},
+			{
+				ID:    "6f3363e0-c0a0-4618-bf1f-b6cad9cdff59",
+				Class: className,
+				Properties: map[string]interface{}{
+					"name": tenantNames[2],
+				},
+				Tenant: tenantNames[2],
+			},
+		}
+
+		t.Run("add tenant objects", func(t *testing.T) {
+			for _, obj := range tenantObjects {
+				assert.Nil(t, helper.CreateObject(t, obj))
+			}
+		})
+
+		t.Run("verify object creation", func(t *testing.T) {
+			for i, obj := range tenantObjects {
+				resp, err := helper.TenantObject(t, obj.Class, obj.ID, tenantNames[i])
+				require.Nil(t, err)
+				assert.Equal(t, obj.Class, resp.Class)
+				assert.Equal(t, obj.Properties, resp.Properties)
+			}
+		})
+
+		t.Run("updating tenant status", func(t *testing.T) {
+			helper.UpdateTenants(t, className, []*models.Tenant{
+				{
+					Name:           tenantNames[0],
+					ActivityStatus: models.TenantActivityStatusFROZEN,
+				},
+			})
+		})
+
+		t.Run("verify tenant status FREEZING", func(t *testing.T) {
+			resp, err := helper.GetTenants(t, className)
+			require.Nil(t, err)
+
+			for _, tn := range resp.Payload {
+				if tn.Name == tenantNames[0] {
+					require.Equal(t, types.TenantActivityStatusFREEZING, tn.ActivityStatus)
+					break
+				}
+			}
+		})
+
+		t.Run("terminate Minio", func(t *testing.T) {
+			require.Nil(t, compose.TerminateContainer(ctx, docker.MinIO))
+		})
+
+		t.Run("verify tenant status HOT", func(xt *testing.T) {
+			assert.EventuallyWithT(t, func(at *assert.CollectT) {
+				resp, err := helper.GetTenants(xt, className)
+				require.Nil(t, err)
+
+				for _, tn := range resp.Payload {
+					if tn.Name == tenantNames[0] {
+						assert.Equal(at, models.TenantActivityStatusHOT, tn.ActivityStatus)
+						break
+					}
+				}
+			}, 5*time.Second, time.Second, fmt.Sprintf("tenant was never %s", models.TenantActivityStatusHOT))
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/qna-transformers/qna_test.go

@@ -0,0 +1,107 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+	graphqlhelper "github.com/weaviate/weaviate/test/helper/graphql"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/books"
+)
+
+func Test_QnATransformers(t *testing.T) {
+	helper.SetupClient(os.Getenv(weaviateEndpoint))
+	// Contextionary with QnA module config present
+	booksClass := books.ClassContextionaryVectorizerWithQnATransformers()
+	helper.CreateClass(t, booksClass)
+	defer helper.DeleteClass(t, booksClass.Class)
+	// Contextionary without QnA module config present
+	booksWithoutQnAConfig := "BooksWithoutConfig"
+	booksWithoutQnAConfigClass := books.ClassContextionaryVectorizerWithName(booksWithoutQnAConfig)
+	helper.CreateClass(t, booksWithoutQnAConfigClass)
+	defer helper.DeleteClass(t, booksWithoutQnAConfigClass.Class)
+	// Text2VecTransformers with QnA module config present
+	booksTransformers := "BooksTransformers"
+	booksTransformersClass := books.ClassTransformersVectorizerWithQnATransformersWithName(booksTransformers)
+	helper.CreateClass(t, booksTransformersClass)
+	defer helper.DeleteClass(t, booksTransformersClass.Class)
+	// Text2VecTransformers without QnA module config present
+	booksTransformersWithoutQnAConfig := "BooksTransformersWithoutConfig"
+	booksTransformersWithoutQnAConfigClass := books.ClassTransformersVectorizerWithName(booksTransformersWithoutQnAConfig)
+	helper.CreateClass(t, booksTransformersWithoutQnAConfigClass)
+	defer helper.DeleteClass(t, booksTransformersWithoutQnAConfigClass.Class)
+
+	t.Run("add data to Books schema", func(t *testing.T) {
+		bookObjects := []*models.Object{}
+		bookObjects = append(bookObjects, books.Objects()...)
+		bookObjects = append(bookObjects, books.ObjectsWithName(booksWithoutQnAConfig)...)
+		bookObjects = append(bookObjects, books.ObjectsWithName(booksTransformers)...)
+		bookObjects = append(bookObjects, books.ObjectsWithName(booksTransformersWithoutQnAConfig)...)
+		for _, book := range bookObjects {
+			helper.CreateObject(t, book)
+			helper.AssertGetObjectEventually(t, book.Class, book.ID)
+		}
+	})
+
+	t.Run("ask", func(t *testing.T) {
+		for _, class := range []*models.Class{booksClass, booksWithoutQnAConfigClass, booksTransformersClass, booksTransformersWithoutQnAConfigClass} {
+			t.Run(class.Class, func(t *testing.T) {
+				query := `
+					{
+						Get {
+							%s(
+								ask: {
+									question: "Who is Dune's author?"
+								}
+								limit: 1
+							){
+								title
+								_additional {
+									answer {
+										hasAnswer
+										property
+										result
+										startPosition
+										endPosition
+									}
+								}
+							}
+						}
+					}
+				`
+				result := graphqlhelper.AssertGraphQL(t, helper.RootAuth, fmt.Sprintf(query, class.Class))
+				books := result.Get("Get", class.Class).AsSlice()
+				expected := []interface{}{
+					map[string]interface{}{
+						"title": "Dune",
+						"_additional": map[string]interface{}{
+							"answer": map[string]interface{}{
+								"endPosition":   json.Number("74"),
+								"hasAnswer":     true,
+								"property":      "description",
+								"result":        "frank herbert",
+								"startPosition": json.Number("61"),
+							},
+						},
+					},
+				}
+				assert.ElementsMatch(t, expected, books)
+			})
+		}
+	})
+}

platform/dbops/binaries/weaviate-src/test/modules/qna-transformers/setup_test.go

@@ -0,0 +1,45 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+const weaviateEndpoint = "WEAVIATE_ENDPOINT"
+
+func TestMain(m *testing.M) {
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviate().
+		WithText2VecContextionary().
+		WithText2VecTransformers().
+		WithQnATransformers().
+		Start(ctx)
+	if err != nil {
+		panic(errors.Wrapf(err, "cannot start"))
+	}
+
+	os.Setenv(weaviateEndpoint, compose.GetWeaviate().URI())
+	code := m.Run()
+
+	if err := compose.Terminate(ctx); err != nil {
+		panic(errors.Wrapf(err, "cannot terminate"))
+	}
+
+	os.Exit(code)
+}

platform/dbops/binaries/weaviate-src/test/modules/ref2vec-centroid/centroid_test.go

@@ -0,0 +1,212 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema/crossref"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func TestCentroid(t *testing.T) {
+	helper.SetupClient(os.Getenv(weaviateEndpoint))
+
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+	articleClass.ModuleConfig = map[string]interface{}{
+		"ref2vec-centroid": map[string]interface{}{
+			"referenceProperties": []string{"hasParagraphs"},
+		},
+	}
+	articleClass.Vectorizer = "ref2vec-centroid"
+
+	helper.CreateClass(t, paragraphClass)
+	helper.CreateClass(t, articleClass)
+
+	defer func() {
+		helper.DeleteClass(t, articleClass.Class)
+		helper.DeleteClass(t, paragraphClass.Class)
+	}()
+
+	para1 := articles.NewParagraph().
+		WithVector([]float32{2, 4, 6}).
+		WithContents(
+			"Anyone who cares about JDM engines knows about the RB26.")
+	helper.CreateObject(t, para1.Object())
+
+	para2 := articles.NewParagraph().
+		WithVector([]float32{4, 6, 8}).
+		WithContents(
+			"It is best known for its use in the legendary Skyline GT-R.")
+	helper.CreateObject(t, para2.Object())
+
+	t.Run("create object with references", func(t *testing.T) {
+		t.Run("with one reference", func(t *testing.T) {
+			article := articles.NewArticle().
+				WithTitle("Popularity of the Nissan RB26DETT").
+				WithReferences(&models.SingleRef{
+					Beacon: newBeacon(para1.Class, para1.ID),
+				})
+			helper.CreateObject(t, article.Object())
+			defer helper.DeleteObject(t, article.Object())
+
+			res := helper.AssertGetObject(t, article.Class, article.ID, "vector")
+			assert.EqualValues(t, para1.Vector, res.Vector)
+		})
+
+		t.Run("with multiple references", func(t *testing.T) {
+			article := articles.NewArticle().
+				WithTitle("Popularity of the Nissan RB26DETT").
+				WithReferences(
+					&models.SingleRef{Beacon: newBeacon(para1.Class, para1.ID)},
+					&models.SingleRef{Beacon: newBeacon(para2.Class, para2.ID)},
+				)
+			helper.CreateObject(t, article.Object())
+			defer helper.DeleteObject(t, article.Object())
+
+			res := helper.AssertGetObject(t, article.Class, article.ID, "vector")
+			expectedVec := []float32{3, 5, 7}
+			assert.EqualValues(t, expectedVec, res.Vector)
+		})
+	})
+
+	t.Run("create object and PUT references", func(t *testing.T) {
+		article := articles.NewArticle().
+			WithTitle("Popularity of the Nissan RB26DETT")
+
+		helper.CreateObject(t, article.Object())
+		defer helper.DeleteObject(t, article.Object())
+
+		res := helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.Nil(t, res.Vector)
+		assert.Equal(t, article.ID, res.ID)
+
+		article.WithReferences(
+			&models.SingleRef{Beacon: newBeacon(para1.Class, para1.ID)},
+			&models.SingleRef{Beacon: newBeacon(para2.Class, para2.ID)},
+		)
+
+		helper.UpdateObject(t, article.Object())
+
+		res = helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.Equal(t, article.ID, res.ID)
+		expectedVec := []float32{3, 5, 7}
+		assert.EqualValues(t, expectedVec, res.Vector)
+	})
+
+	t.Run("create object with references, remove references", func(t *testing.T) {
+		ref1 := &models.SingleRef{Beacon: newBeacon(para1.Class, para1.ID)}
+		ref2 := &models.SingleRef{Beacon: newBeacon(para2.Class, para2.ID)}
+
+		article := articles.NewArticle().
+			WithTitle("Popularity of the Nissan RB26DETT").
+			WithReferences(ref1, ref2)
+		helper.CreateObject(t, article.Object())
+		defer helper.DeleteObject(t, article.Object())
+
+		res := helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		expectedVec := []float32{3, 5, 7}
+		assert.EqualValues(t, expectedVec, res.Vector)
+
+		helper.DeleteReference(t, article.Object(), ref2, "hasParagraphs")
+		res = helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.EqualValues(t, para1.Vector, res.Vector)
+
+		helper.DeleteReference(t, article.Object(), ref1, "hasParagraphs")
+		res = helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.Nil(t, res.Vector)
+	})
+
+	t.Run("create object add references, remove references", func(t *testing.T) {
+		ref1 := &models.SingleRef{Beacon: newBeacon(para1.Class, para1.ID)}
+		ref2 := &models.SingleRef{Beacon: newBeacon(para2.Class, para2.ID)}
+
+		article := articles.NewArticle().
+			WithTitle("Popularity of the Nissan RB26DETT")
+		helper.CreateObject(t, article.Object())
+		defer helper.DeleteObject(t, article.Object())
+
+		res := helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.Nil(t, res.Vector)
+
+		helper.AddReference(t, article.Object(), ref1, "hasParagraphs")
+		res = helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.EqualValues(t, para1.Vector, res.Vector)
+
+		helper.AddReference(t, article.Object(), ref2, "hasParagraphs")
+		res = helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.EqualValues(t, []float32{3, 5, 7}, res.Vector)
+
+		helper.DeleteReference(t, article.Object(), ref1, "hasParagraphs")
+		res = helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.EqualValues(t, para2.Vector, res.Vector)
+
+		helper.DeleteReference(t, article.Object(), ref2, "hasParagraphs")
+		res = helper.AssertGetObject(t, article.Class, article.ID, "vector")
+		assert.Nil(t, res.Vector)
+	})
+
+	t.Run("batch create objects", func(t *testing.T) {
+		ref1 := &models.SingleRef{Beacon: newBeacon(para1.Class, para1.ID)}
+		ref2 := &models.SingleRef{Beacon: newBeacon(para2.Class, para2.ID)}
+
+		article1 := articles.NewArticle().
+			WithTitle("Popularity of the Nissan RB26DETT").
+			WithReferences(ref1, ref2)
+		defer helper.DeleteObject(t, article1.Object())
+
+		article2 := articles.NewArticle().
+			WithTitle("A Nissan RB Origin Story").
+			WithReferences(ref1, ref2)
+		defer helper.DeleteObject(t, article2.Object())
+
+		batch := []*models.Object{article1.Object(), article2.Object()}
+		helper.CreateObjectsBatch(t, batch)
+
+		res := helper.AssertGetObject(t, article1.Class, article1.ID, "vector")
+		assert.EqualValues(t, []float32{3, 5, 7}, res.Vector)
+		res = helper.AssertGetObject(t, article2.Class, article2.ID, "vector")
+		assert.EqualValues(t, []float32{3, 5, 7}, res.Vector)
+	})
+
+	// TODO: Uncomment when batch refs supports centroid re-calc
+	//t.Run("batch create references", func(t *testing.T) {
+	//	article := articles.NewArticle().
+	//		WithTitle("Popularity of the Nissan RB26DETT")
+	//	defer helper.DeleteObject(t, article.Object())
+	//
+	//	refs := []*models.BatchReference{
+	//		{
+	//			From: strfmt.URI(crossref.NewSource("Article", "hasParagraphs", article.ID).String()),
+	//			To:   strfmt.URI(crossref.NewLocalhost("Paragraph", para1.ID).String()),
+	//		},
+	//		{
+	//			From: strfmt.URI(crossref.NewSource("Article", "hasParagraphs", article.ID).String()),
+	//			To:   strfmt.URI(crossref.NewLocalhost("Paragraph", para2.ID).String()),
+	//		},
+	//	}
+	//
+	//	helper.AddReferences(t, refs)
+	//	res := helper.AssertGetObject(t, article.Class, article.ID, "vector")
+	//	assert.EqualValues(t, []float32{3, 5, 7}, res.Vector)
+	//})
+}
+
+func newBeacon(className string, id strfmt.UUID) strfmt.URI {
+	return crossref.New("localhost", className, id).SingleRef().Beacon
+}

platform/dbops/binaries/weaviate-src/test/modules/ref2vec-centroid/setup_test.go

@@ -0,0 +1,42 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+const weaviateEndpoint = "WEAVIATE_ENDPOINT"
+
+func TestMain(m *testing.M) {
+	ctx := context.Background()
+	compose, err := docker.New().
+		WithWeaviate().WithRef2VecCentroid().
+		Start(ctx)
+	if err != nil {
+		panic(errors.Wrapf(err, "cannot start"))
+	}
+
+	os.Setenv(weaviateEndpoint, compose.GetWeaviate().URI())
+	code := m.Run()
+
+	if err := compose.Terminate(ctx); err != nil {
+		panic(errors.Wrapf(err, "cannot terminate"))
+	}
+
+	os.Exit(code)
+}