Add files using upload-large-folder tool

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_aggregate.go

@@ -0,0 +1,113 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+const (
+	UUID1 = "f47ac10b-58cc-0372-8567-0e02b2c3d479"
+	UUID2 = "f47ac10b-58cc-0372-8567-0e02b2c3d480"
+)
+
+func testAggregate(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+		ctx := context.Background()
+
+		classAggregate := "NamedAggregateTest"
+
+		// delete class if exists and cleanup after test
+		err = client.Schema().ClassDeleter().WithClassName(classAggregate).Do(ctx)
+		require.Nil(t, err)
+
+		defer client.Schema().ClassDeleter().WithClassName(classAggregate).Do(ctx)
+
+		// create class and objects
+		class := &models.Class{
+			Class: classAggregate,
+			Properties: []*models.Property{
+				{
+					Name: "first", DataType: []string{schema.DataTypeText.String()},
+				},
+				{
+					Name: "second", DataType: []string{schema.DataTypeText.String()},
+				},
+				{
+					Name: "number", DataType: []string{schema.DataTypeInt.String()},
+				},
+			},
+			VectorConfig: map[string]models.VectorConfig{
+				"first": {
+					Vectorizer: map[string]interface{}{
+						"text2vec-model2vec": map[string]interface{}{
+							"vectorizeClassName": false,
+							"properties":         []string{"first"},
+						},
+					},
+					VectorIndexType: "hnsw",
+				},
+				"second": {
+					Vectorizer: map[string]interface{}{
+						"text2vec-model2vec": map[string]interface{}{
+							"vectorizeClassName": false,
+							"properties":         []string{"second"},
+						},
+					},
+					VectorIndexType: "hnsw",
+				},
+			},
+		}
+		require.Nil(t, client.Schema().ClassCreator().WithClass(class).Do(ctx))
+
+		creator := client.Data().Creator()
+		_, err = creator.WithClassName(classAggregate).WithProperties(
+			map[string]interface{}{"first": "Hello", "second": "World", "number": 1}).WithID(UUID1).Do(ctx)
+		require.Nil(t, err)
+		_, err = creator.WithClassName(classAggregate).WithProperties(
+			map[string]interface{}{"first": "World", "second": "Hello", "number": 2}).WithID(UUID2).Do(ctx)
+		require.Nil(t, err)
+
+		// aggregate
+		no := &graphql.NearObjectArgumentBuilder{}
+		no.WithTargetVectors("first").WithID(UUID1).WithCertainty(0.9)
+
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			agg, err := client.GraphQL().Aggregate().WithClassName(classAggregate).WithNearObject(no).WithFields(graphql.Field{Name: "number", Fields: []graphql.Field{{Name: "maximum"}}}).Do(ctx)
+			require.Nil(ct, err)
+
+			assert.NotNil(ct, agg)
+			assert.Nil(ct, agg.Errors)
+			assert.NotNil(ct, agg.Data)
+			assert.Equal(ct, agg.Data["Aggregate"].(map[string]interface{})[classAggregate].([]interface{})[0].(map[string]interface{})["number"].(map[string]interface{})["maximum"], float64(1))
+
+			// aggregate without needed a target vector
+			agg, err = client.GraphQL().Aggregate().WithClassName(classAggregate).WithFields(graphql.Field{Name: "meta", Fields: []graphql.Field{{Name: "count"}}}).Do(ctx)
+			assert.Nil(ct, err)
+			assert.NotNil(ct, agg)
+			assert.Nil(ct, agg.Errors)
+			assert.NotNil(ct, agg.Data)
+			assert.Equal(ct, agg.Data["Aggregate"].(map[string]interface{})[classAggregate].([]interface{})[0].(map[string]interface{})["meta"].(map[string]interface{})["count"], float64(2))
+		}, 15*time.Second, 500*time.Millisecond)
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_batch.go

@@ -0,0 +1,323 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/filters"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testBatchObject(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		idsToDelete := []string{id1, id2}
+		hasBeenDeleted := func(id string) bool {
+			for _, deletedId := range idsToDelete {
+				if deletedId == id {
+					return true
+				}
+			}
+			return false
+		}
+
+		t.Run("multiple named vectors", func(t *testing.T) {
+			cleanup()
+
+			t.Run("create schema", func(t *testing.T) {
+				createNamedVectorsClass(t, client)
+			})
+
+			t.Run("batch create objects", func(t *testing.T) {
+				objs := []*models.Object{}
+				for id, book := range fixtures.Books() {
+					obj := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(id),
+						Properties: map[string]interface{}{
+							"text": book.Description,
+						},
+					}
+					objs = append(objs, obj)
+				}
+
+				resp, err := client.Batch().ObjectsBatcher().
+					WithObjects(objs...).
+					Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+			})
+
+			t.Run("check existence", func(t *testing.T) {
+				for id := range fixtures.Books() {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						Do(ctx)
+					require.NoError(t, err)
+					require.True(t, exists)
+				}
+			})
+
+			t.Run("check if all objects have been indexed", func(t *testing.T) {
+				testAllObjectsIndexed(t, client, className)
+			})
+
+			t.Run("GraphQL get vectors", func(t *testing.T) {
+				for id := range fixtures.Books() {
+					resultVectors := getVectors(t, client, className, id, targetVectors...)
+					checkTargetVectors(t, resultVectors)
+				}
+			})
+
+			t.Run("GraphQL near<Media> check", func(t *testing.T) {
+				for id, book := range fixtures.Books() {
+					for _, targetVector := range targetVectors {
+						nearText := client.GraphQL().NearTextArgBuilder().
+							WithConcepts([]string{book.Title}).
+							WithTargetVectors(targetVector)
+						resultVectors := getVectorsWithNearText(t, client, className, id, nearText, targetVectors...)
+						checkTargetVectors(t, resultVectors)
+					}
+				}
+			})
+
+			t.Run("batch delete objects", func(t *testing.T) {
+				where := filters.Where().
+					WithPath([]string{"id"}).
+					WithOperator(filters.ContainsAny).
+					WithValueText(idsToDelete...)
+				resp, err := client.Batch().ObjectsBatchDeleter().
+					WithClassName(className).
+					WithDryRun(true).
+					WithOutput("verbose").
+					WithWhere(where).
+					Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Results)
+				require.Len(t, resp.Results.Objects, 2)
+				for _, res := range resp.Results.Objects {
+					require.Nil(t, res.Errors)
+					require.NotNil(t, res.Status)
+					assert.Equal(t, models.BatchDeleteResponseResultsObjectsItems0StatusDRYRUN, *res.Status)
+				}
+
+				resp, err = client.Batch().ObjectsBatchDeleter().
+					WithClassName(className).
+					WithDryRun(false).
+					WithOutput("verbose").
+					WithWhere(where).
+					Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Results)
+				require.Len(t, resp.Results.Objects, 2)
+				for _, res := range resp.Results.Objects {
+					require.Nil(t, res.Errors)
+					require.NotNil(t, res.Status)
+					assert.Equal(t, models.BatchDeleteResponseResultsObjectsItems0StatusSUCCESS, *res.Status)
+				}
+
+				for id := range fixtures.Books() {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						Do(ctx)
+					require.NoError(t, err)
+					isDeleted := false
+					for _, deletedID := range idsToDelete {
+						if id == deletedID {
+							isDeleted = true
+							break
+						}
+					}
+					require.Equal(t, !isDeleted, exists)
+				}
+			})
+
+			t.Run("batch update objects and check if vectors changed", func(t *testing.T) {
+				existingIds := []string{}
+				for id := range fixtures.Books() {
+					if !hasBeenDeleted(id) {
+						existingIds = append(existingIds, id)
+					}
+				}
+				beforeUpdateVectorsMap := map[string]map[string][]float32{}
+				for _, id := range existingIds {
+					beforeUpdateVectors := getVectors(t, client, className, id, targetVectors...)
+					checkTargetVectors(t, beforeUpdateVectors)
+				}
+
+				objs := []*models.Object{}
+				for id, book := range fixtures.Books() {
+					obj := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(id),
+						Properties: map[string]interface{}{
+							"text": book.Title,
+						},
+					}
+					objs = append(objs, obj)
+				}
+				resp, err := client.Batch().ObjectsBatcher().
+					WithObjects(objs...).
+					Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+
+				for _, id := range existingIds {
+					afterUpdateVectors := getVectors(t, client, className, id, targetVectors...)
+					checkTargetVectors(t, afterUpdateVectors)
+					beforeUpdateVectors := beforeUpdateVectorsMap[id]
+					for _, targetVector := range targetVectors {
+						assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+					}
+				}
+			})
+		})
+
+		t.Run("bring your own vectors", func(t *testing.T) {
+			cleanup()
+			tests := []struct {
+				name                   string
+				className              string
+				vectorConfig           map[string]models.VectorConfig
+				vectors                models.Vectors
+				generatedTargetVectors []string
+			}{
+				{
+					name:      "with 2 none vectorizers",
+					className: "OnlyNoneVectorizers",
+					vectorConfig: map[string]models.VectorConfig{
+						"none1": {
+							Vectorizer: map[string]interface{}{
+								"none": nil,
+							},
+							VectorIndexType: "hnsw",
+						},
+						"none2": {
+							Vectorizer: map[string]interface{}{
+								"none": nil,
+							},
+							VectorIndexType: "flat",
+						},
+					},
+					vectors: models.Vectors{
+						"none1": []float32{1, 2},
+						"none2": []float32{0.11, 0.22, 0.33},
+					},
+				},
+				{
+					name:      "with 2 none vectorizers and 2 generated vectors",
+					className: "NoneAndGeneratedVectorizers",
+					vectorConfig: map[string]models.VectorConfig{
+						"none1": {
+							Vectorizer: map[string]interface{}{
+								"none": nil,
+							},
+							VectorIndexType: "hnsw",
+						},
+						"none2": {
+							Vectorizer: map[string]interface{}{
+								"none": nil,
+							},
+							VectorIndexType: "flat",
+						},
+						m2vec: {
+							Vectorizer: map[string]interface{}{
+								text2vecModel2Vec: map[string]interface{}{
+									"vectorizeClassName": false,
+								},
+							},
+							VectorIndexType: "hnsw",
+						},
+						transformers_flat: {
+							Vectorizer: map[string]interface{}{
+								text2vecTransformers: map[string]interface{}{
+									"vectorizeClassName": false,
+								},
+							},
+							VectorIndexType: "flat",
+						},
+					},
+					vectors: models.Vectors{
+						"none1": []float32{1, 2},
+						"none2": []float32{0.11, 0.22, 0.33},
+					},
+					generatedTargetVectors: []string{m2vec, transformers_flat},
+				},
+			}
+			for _, tt := range tests {
+				class := &models.Class{
+					Class: tt.className,
+					Properties: []*models.Property{
+						{
+							Name:     "name",
+							DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorConfig: tt.vectorConfig,
+				}
+				err = client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.NoError(t, err)
+				// perform batch import
+				id := strfmt.UUID("00000000-0000-0000-0000-000000000001")
+				vectors := tt.vectors
+				object := &models.Object{
+					ID:    id,
+					Class: tt.className,
+					Properties: map[string]interface{}{
+						"name": "some name",
+					},
+					Vectors: vectors,
+				}
+				batchResponse, err := client.Batch().ObjectsBatcher().WithObjects(object).Do(ctx)
+				require.NoError(t, err)
+				assert.NotNil(t, batchResponse)
+				assert.Equal(t, 1, len(batchResponse))
+				// get object
+				objs, err := client.Data().ObjectsGetter().
+					WithClassName(tt.className).WithID(id.String()).WithVector().
+					Do(ctx)
+				require.NoError(t, err)
+				require.NotEmpty(t, objs)
+				require.Len(t, objs, 1)
+				assert.Equal(t, id, objs[0].ID)
+				require.Len(t, objs[0].Vectors, len(tt.vectors)+len(tt.generatedTargetVectors))
+				for targetVector, vector := range objs[0].Vectors {
+					assert.Equal(t, vector, objs[0].Vectors[targetVector])
+				}
+				for _, generatedTargetVector := range tt.generatedTargetVectors {
+					assert.NotEmpty(t, objs[0].Vectors[generatedTargetVector])
+				}
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_byov_with_vectorizer.go

@@ -0,0 +1,113 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+const (
+	UUID3 = "00000000-0000-0000-0000-000000000001"
+	UUID4 = "00000000-0000-0000-0000-000000000002"
+)
+
+func testCreateSchemaWithVectorizerAndBYOV(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+		require.Nil(t, client.Schema().AllDeleter().Do(context.Background()))
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		defer cleanup()
+
+		className := "BYOVwithVectorizer"
+
+		class := &models.Class{
+			Class: className,
+			Properties: []*models.Property{
+				{
+					Name: "text", DataType: []string{schema.DataTypeText.String()},
+				},
+			},
+			VectorConfig: map[string]models.VectorConfig{
+				"byov": {
+					Vectorizer: map[string]interface{}{
+						"text2vec-model2vec": map[string]interface{}{
+							"vectorizeClassName": false,
+						},
+					},
+					VectorIndexType: "hnsw",
+				},
+				"generate": {
+					Vectorizer: map[string]interface{}{
+						"text2vec-model2vec": map[string]interface{}{
+							"vectorizeClassName": false,
+						},
+					},
+					VectorIndexType: "hnsw",
+				},
+			},
+		}
+
+		require.NoError(t, client.Schema().ClassCreator().WithClass(class).Do(ctx))
+
+		_, err = client.Data().Creator().
+			WithClassName(className).
+			WithID(UUID3).
+			WithProperties(map[string]interface{}{
+				"text": "banana",
+			}).
+			Do(ctx)
+		require.NoError(t, err)
+
+		objWithoutVector, err := client.Data().ObjectsGetter().
+			WithClassName(className).
+			WithID(UUID3).
+			WithVector().
+			Do(ctx)
+		require.NoError(t, err)
+		require.Len(t, objWithoutVector, 1)
+		require.Len(t, objWithoutVector[0].Vectors["byov"], 512)
+
+		// add an object with the same vector but different properties
+		_, err = client.Data().Creator().
+			WithClassName(className).
+			WithID(UUID4).
+			WithProperties(map[string]interface{}{
+				"text": "apple",
+			}).WithVectors(models.Vectors{"byov": objWithoutVector[0].Vectors["byov"]}).
+			Do(ctx)
+
+		// vector "byov" must be the same as the same vector was explicitly given to the second object
+		// vector "generated" must be different because it gets generated on different data for both objects
+		objWithVector, err := client.Data().ObjectsGetter().
+			WithClassName(className).
+			WithID(UUID4).
+			WithVector().
+			Do(ctx)
+		require.NoError(t, err)
+		require.Len(t, objWithoutVector, 1)
+		require.Equal(t, objWithVector[0].Vectors["byov"], objWithoutVector[0].Vectors["byov"])
+		require.NotEqual(t, objWithVector[0].Vectors["generate"], objWithoutVector[0].Vectors["generate"])
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_colbert.go

@@ -0,0 +1,788 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	acceptance_with_go_client "acceptance_tests_with_client"
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/filters"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testColBERT(host string, asyncIndexingEnabled bool) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("bring your own multivector", func(t *testing.T) {
+			cleanup()
+
+			className := fixtures.BringYourOwnColBERTClassName
+			objects := fixtures.BringYourOwnColBERTObjects
+			byoc := fixtures.BringYourOwnColBERTNamedVectorName
+			normalVector2dName := fixtures.NormalVector2dName
+			multiVector1dName := fixtures.MultiVector1dName
+			multiVector2dName := fixtures.MultiVector2dName
+			multiVector3dName := fixtures.MultiVector3dName
+			multiVector1dFromMultiVector2d := func(mv [][]float32) [][]float32 {
+				multiVector1d := make([][]float32, len(mv))
+				for i, v := range mv {
+					multiVector1d[i] = []float32{v[0]}
+				}
+				return multiVector1d
+			}
+			multiVector3dFromMultiVector2d := func(mv [][]float32) [][]float32 {
+				multiVector3d := make([][]float32, len(mv))
+				for i, v := range mv {
+					multiVector3d[i] = []float32{v[0], v[1], v[1]}
+				}
+				return multiVector3d
+			}
+
+			_additional_byoc := graphql.Field{
+				Name: "_additional",
+				Fields: []graphql.Field{
+					{Name: "id"},
+					{Name: fmt.Sprintf("vectors{%s}", byoc)},
+				},
+			}
+
+			performNearVector := func(t *testing.T, ct *assert.CollectT, client *wvt.Client, className string) {
+				nearVector := client.GraphQL().NearVectorArgBuilder().
+					WithVector([][]float32{{-0.000001, -0.000001}, {-0.000001, -0.000001}, {-0.000001, -0.000001}}).
+					WithTargetVectors(byoc)
+				resp, err := client.GraphQL().Get().
+					WithClassName(className).
+					WithNearVector(nearVector).
+					WithFields(_additional_byoc).
+					Do(ctx)
+				require.NoError(t, err)
+				ids := acceptance_with_go_client.GetIds(t, resp, className)
+				require.NotEmpty(t, ids)
+				if ct != nil {
+					// adds ability to be used with assert.EventuallyWithT(...)
+					assert.Len(ct, ids, len(objects))
+				} else {
+					assert.Len(t, ids, len(objects))
+				}
+			}
+
+			performNearObject := func(t *testing.T, ct *assert.CollectT, client *wvt.Client, className string) {
+				nearObject := client.GraphQL().NearObjectArgBuilder().
+					WithID(objects[0].ID).
+					WithTargetVectors(byoc)
+				resp, err := client.GraphQL().Get().
+					WithClassName(className).
+					WithNearObject(nearObject).
+					WithFields(_additional_byoc).
+					Do(ctx)
+				require.NoError(t, err)
+				ids := acceptance_with_go_client.GetIds(t, resp, className)
+				require.NotEmpty(t, ids)
+				if ct != nil {
+					// adds ability to be used with assert.EventuallyWithT(...)
+					assert.Len(ct, ids, len(objects))
+				} else {
+					assert.Len(t, ids, len(objects))
+				}
+			}
+
+			t.Run("create schema", func(t *testing.T) {
+				class := fixtures.BringYourOwnColBERTClass(className)
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.NoError(t, err)
+			})
+
+			t.Run("batch create objects", func(t *testing.T) {
+				objs := []*models.Object{}
+				for _, o := range objects {
+					obj := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(o.ID),
+						Properties: map[string]interface{}{
+							"name": o.Name,
+						},
+						Vectors: models.Vectors{
+							byoc:               o.Vector,
+							normalVector2dName: o.Vector[0],
+							multiVector1dName:  multiVector1dFromMultiVector2d(o.Vector),
+							multiVector2dName:  o.Vector,
+							multiVector3dName:  multiVector3dFromMultiVector2d(o.Vector),
+						},
+					}
+					objs = append(objs, obj)
+				}
+
+				resp, err := client.Batch().ObjectsBatcher().
+					WithObjects(objs...).
+					Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+				for _, r := range resp {
+					require.Equal(t, "SUCCESS", *r.Result.Status)
+				}
+			})
+
+			t.Run("checks objects indexed", func(t *testing.T) {
+				testAllObjectsIndexed(t, client, className)
+			})
+
+			t.Run("vector search after insert", func(t *testing.T) {
+				performNearVector(t, nil, client, className)
+				performNearObject(t, nil, client, className)
+			})
+
+			t.Run("check existence", func(t *testing.T) {
+				for _, obj := range objects {
+					exists, err := client.Data().Checker().
+						WithID(obj.ID).
+						WithClassName(className).
+						Do(ctx)
+					require.NoError(t, err)
+					require.True(t, exists)
+				}
+			})
+
+			t.Run("get objects with vector", func(t *testing.T) {
+				for _, o := range objects {
+					objs, err := client.Data().ObjectsGetter().WithID(o.ID).WithClassName(className).WithVector().Do(ctx)
+					require.NoError(t, err)
+					require.Len(t, objs, 1)
+					require.Len(t, objs[0].Vectors, 5)
+					assert.IsType(t, [][]float32{}, objs[0].Vectors[byoc])
+					assert.Equal(t, o.Vector, objs[0].Vectors[byoc])
+				}
+			})
+
+			t.Run("GraphQL get object with vector", func(t *testing.T) {
+				for _, o := range objects {
+					resp, err := client.GraphQL().Get().
+						WithClassName(className).
+						WithWhere(filters.Where().WithPath([]string{"id"}).WithOperator(filters.Equal).WithValueText(o.ID)).
+						WithFields(_additional_byoc).
+						Do(ctx)
+					require.NoError(t, err)
+					vectors := acceptance_with_go_client.GetVectors(t, resp, className, false, byoc)
+					require.Len(t, vectors, 1)
+					require.IsType(t, [][]float32{}, vectors[byoc])
+					assert.Equal(t, o.Vector, vectors[byoc])
+				}
+			})
+
+			t.Run("update vector", func(t *testing.T) {
+				tests := []struct {
+					name string
+					obj  struct {
+						ID     string
+						Name   string
+						Vector [][]float32
+					}
+					withMerge bool
+					vector    [][]float32
+				}{
+					{
+						name:   "update",
+						obj:    objects[0],
+						vector: [][]float32{{-0.11111111, -0.12222222}, {-0.13, -0.14}, {-0.15, -0.16}},
+					},
+					{
+						name:      "merge",
+						obj:       objects[1],
+						withMerge: true,
+						vector:    [][]float32{{-0.000001, -0.000001}, {-0.000001, -0.000001}, {-0.000001, -0.000001}},
+					},
+				}
+				for _, tt := range tests {
+					t.Run(tt.name, func(t *testing.T) {
+						firstObj := tt.obj
+						updateVectors := models.Vectors{
+							byoc:               tt.vector,
+							normalVector2dName: tt.vector[0],
+							multiVector1dName:  multiVector1dFromMultiVector2d(tt.vector),
+							multiVector2dName:  tt.vector,
+							multiVector3dName:  multiVector3dFromMultiVector2d(tt.vector),
+						}
+						objs, err := client.Data().ObjectsGetter().
+							WithClassName(className).WithID(firstObj.ID).WithVector().Do(ctx)
+						require.NoError(t, err)
+						require.NotEmpty(t, objs)
+						require.Len(t, objs[0].Vectors, 5)
+						assert.Equal(t, firstObj.Vector, objs[0].Vectors[byoc])
+						updater := client.Data().Updater().
+							WithClassName(className).WithID(firstObj.ID).WithVectors(updateVectors)
+						if tt.withMerge {
+							err = updater.WithMerge().Do(ctx)
+						} else {
+							err = updater.Do(ctx)
+						}
+						require.NoError(t, err)
+						objs, err = client.Data().ObjectsGetter().
+							WithClassName(className).WithID(firstObj.ID).WithVector().Do(ctx)
+						require.NoError(t, err)
+						require.NotEmpty(t, objs)
+						require.Len(t, objs[0].Vectors, 5)
+						assert.Equal(t, updateVectors[byoc], objs[0].Vectors[byoc])
+						resp, err := client.GraphQL().Get().
+							WithClassName(className).
+							WithWhere(filters.Where().WithPath([]string{"id"}).WithOperator(filters.Equal).WithValueText(firstObj.ID)).
+							WithFields(_additional_byoc).
+							Do(ctx)
+						require.NoError(t, err)
+						vectors := acceptance_with_go_client.GetVectors(t, resp, className, false, byoc)
+						require.Len(t, vectors, 1)
+						require.IsType(t, [][]float32{}, vectors[byoc])
+						assert.Equal(t, updateVectors[byoc], vectors[byoc])
+					})
+				}
+			})
+
+			t.Run("checks objects indexed", func(t *testing.T) {
+				testAllObjectsIndexed(t, client, className)
+			})
+
+			t.Run("vector search after partial update", func(t *testing.T) {
+				performNearVector(t, nil, client, className)
+				performNearObject(t, nil, client, className)
+			})
+
+			t.Run("update all objects", func(t *testing.T) {
+				for _, obj := range objects {
+					err = client.Data().Updater().
+						WithClassName(className).WithID(obj.ID).WithVectors(models.Vectors{
+						byoc:               obj.Vector,
+						normalVector2dName: obj.Vector[0],
+						multiVector1dName:  multiVector1dFromMultiVector2d(obj.Vector),
+						multiVector2dName:  obj.Vector,
+						multiVector3dName:  multiVector3dFromMultiVector2d(obj.Vector),
+					}).Do(ctx)
+					require.NoError(t, err)
+				}
+			})
+
+			t.Run("checks objects indexed", func(t *testing.T) {
+				testAllObjectsIndexed(t, client, className)
+			})
+
+			t.Run("vector search after update of all objects", func(t *testing.T) {
+				assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+					performNearVector(t, ct, client, className)
+					performNearObject(t, ct, client, className)
+				}, 5*time.Second, 1*time.Second)
+			})
+
+			t.Run("WithVector[s]PerTarget searches", func(t *testing.T) {
+				withVectorPerTargetTests := []struct {
+					name       string
+					nearVector *graphql.NearVectorArgumentBuilder
+				}{
+					{
+						name: "NormalVector_dim2",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorPerTarget(map[string]models.Vector{
+								normalVector2dName: []float32{0.1, 0.1},
+							}).
+							WithTargetVectors(normalVector2dName),
+					},
+					{
+						name: "NormalVectors_dim3x2",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorsPerTarget(map[string][]models.Vector{
+								normalVector2dName: {[]float32{0.1, 0.1}, []float32{0.1, 0.1}, []float32{0.1, 0.1}},
+							}).
+							WithTargetVectors(normalVector2dName),
+					},
+					{
+						name: "MultiVector_dim3x2",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorPerTarget(map[string]models.Vector{
+								multiVector2dName: [][]float32{{0.1, 0.1}, {0.1, 0.1}, {0.1, 0.1}},
+							}).
+							WithTargetVectors(multiVector2dName),
+					},
+					{
+						name: "MultiVectors_dim1x3x2",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorsPerTarget(map[string][]models.Vector{
+								multiVector2dName: {
+									[][]float32{{0.1, 0.1}, {0.1, 0.1}, {0.1, 0.1}},
+								},
+							}).
+							WithTargetVectors(multiVector2dName),
+					},
+					{
+						name: "MultiVectors_dim2x3x2",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorsPerTarget(map[string][]models.Vector{
+								multiVector2dName: {
+									[][]float32{{0.1, 0.1}, {0.1, 0.1}, {0.1, 0.1}},
+									[][]float32{{0.1, 0.1}, {0.1, 0.1}, {0.1, 0.1}},
+								},
+							}).
+							WithTargetVectors(multiVector2dName),
+					},
+					{
+						name: "MultiVector_1d2d3d",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorPerTarget(map[string]models.Vector{
+								multiVector1dName: [][]float32{{0.1}, {0.1}},
+								multiVector2dName: [][]float32{{0.1, 0.1}, {0.1, 0.1}},
+								multiVector3dName: [][]float32{{0.1, 0.1, 0.1}, {0.1, 0.1, 0.1}},
+							}).
+							WithTargetVectors(multiVector2dName),
+					},
+					{
+						name: "MultiVectors_1d2d3d",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorsPerTarget(map[string][]models.Vector{
+								multiVector1dName: {
+									[][]float32{{0.1}, {0.1}},
+									[][]float32{{0.1}, {0.1}},
+									[][]float32{{0.1}, {0.1}},
+								},
+								multiVector2dName: {
+									[][]float32{{0.1, 0.1}, {0.1, 0.1}},
+									[][]float32{{0.1, 0.1}, {0.1, 0.1}},
+								},
+								multiVector3dName: {
+									[][]float32{{0.1, 0.1, 0.1}, {0.1, 0.1, 0.1}},
+								},
+							}).
+							WithTargetVectors(multiVector2dName),
+					},
+					{
+						name: "MultiVector_all",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorPerTarget(map[string]models.Vector{
+								normalVector2dName: []float32{0.1, 0.1},
+								multiVector1dName:  [][]float32{{0.1}, {0.1}},
+								multiVector2dName:  [][]float32{{0.1, 0.1}, {0.1, 0.1}},
+								multiVector3dName:  [][]float32{{0.1, 0.1, 0.1}, {0.1, 0.1, 0.1}},
+							}).
+							WithTargetVectors(multiVector2dName),
+					},
+					{
+						name: "MultiVectors_all",
+						nearVector: client.GraphQL().NearVectorArgBuilder().
+							WithVectorsPerTarget(map[string][]models.Vector{
+								normalVector2dName: {
+									[]float32{0.1, 0.1},
+									[]float32{0.1, 0.1},
+								},
+								multiVector1dName: {
+									[][]float32{{0.1}, {0.1}},
+									[][]float32{{0.1}, {0.1}},
+								},
+								multiVector2dName: {
+									[][]float32{{0.1, 0.1}, {0.1, 0.1}},
+									[][]float32{{0.1, 0.1}, {0.1, 0.1}},
+								},
+								multiVector3dName: {
+									[][]float32{{0.1, 0.1, 0.1}, {0.1, 0.1, 0.1}},
+									[][]float32{{0.1, 0.1, 0.1}, {0.1, 0.1, 0.1}},
+								},
+							}).
+							WithTargetVectors(multiVector2dName),
+					},
+				}
+				for _, tt := range withVectorPerTargetTests {
+					t.Run(tt.name, func(t *testing.T) {
+						resp, err := client.GraphQL().Get().
+							WithClassName(className).
+							WithNearVector(tt.nearVector).
+							WithFields(_additional_byoc).
+							Do(ctx)
+						require.NoError(t, err)
+						ids := acceptance_with_go_client.GetIds(t, resp, className)
+						require.NotEmpty(t, ids)
+						assert.Len(t, ids, len(objects))
+					})
+				}
+			})
+		})
+
+		t.Run("multi vector validation", func(t *testing.T) {
+			t.Run("multi vector vectorizer", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "MultiVectorLegacyVectorizer",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorIndexType: "hnsw",
+					Vectorizer:      "text2multivec-jinaai",
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.Error(t, err)
+				assert.ErrorContains(t, err, `multi vector vectorizer: \"text2multivec-jinaai\" is only allowed to be defined using named vector configuration`)
+			})
+			t.Run("multi vector vectorizer with module config", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "MultiVectorLegacyVectorizerWithModuleConfig",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					ModuleConfig: map[string]interface{}{
+						"text2multivec-jinaai": map[string]interface{}{
+							"skip": true,
+						},
+					},
+					VectorIndexType: "hnsw",
+					Vectorizer:      "text2multivec-jinaai",
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.Error(t, err)
+				assert.ErrorContains(t, err, `multi vector vectorizer: \"text2multivec-jinaai\" is only allowed to be defined using named vector configuration`)
+			})
+			t.Run("colbert vectorizer with multi vector index", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "LegacyColbertVectorizerWithMultiVectorIndex",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorIndexType: "hnsw",
+					VectorIndexConfig: map[string]interface{}{
+						"multivector": map[string]interface{}{
+							"enabled": true,
+						},
+					},
+					Vectorizer: "text2multivec-jinaai",
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.Error(t, err)
+				assert.ErrorContains(t, err, `class.VectorIndexConfig multi vector type index type is only configurable using named vectors`)
+			})
+			t.Run("regular vectorizer with multi vector index", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "LegacyOpenAIVectorizerWithMultiVectorIndex",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorIndexType: "hnsw",
+					VectorIndexConfig: map[string]interface{}{
+						"multivector": map[string]interface{}{
+							"enabled": true,
+						},
+					},
+					Vectorizer: "text2vec-openai",
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.Error(t, err)
+				assert.ErrorContains(t, err, `class.VectorIndexConfig multi vector type index type is only configurable using named vectors`)
+			})
+			t.Run("legacy none vectorizer with multi vector index", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "LegacyNoneVectorizerWithMultiVectorIndex",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorIndexType: "hnsw",
+					VectorIndexConfig: map[string]interface{}{
+						"multivector": map[string]interface{}{
+							"enabled": true,
+						},
+					},
+					Vectorizer: "none",
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.Error(t, err)
+				assert.ErrorContains(t, err, `class.VectorIndexConfig multi vector type index type is only configurable using named vectors`)
+			})
+			t.Run("named vector regular vectorizer with multi vector index", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "NamedVectorVectorizerWithMultiVectorIndex",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorConfig: map[string]models.VectorConfig{
+						m2vec: {
+							Vectorizer: map[string]interface{}{
+								text2vecModel2Vec: map[string]interface{}{
+									"vectorizeClassName": false,
+								},
+							},
+							VectorIndexConfig: map[string]interface{}{
+								"multivector": map[string]interface{}{
+									"enabled": true,
+								},
+							},
+							VectorIndexType: "hnsw",
+						},
+					},
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.Error(t, err)
+				assert.ErrorContains(t, err, `parse vector config for m2vec: multi vector index configured but vectorizer: \"text2vec-model2vec\" doesn't support multi vectors`)
+			})
+			t.Run("named vector is colbert vectorizer with regular vector index", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "NamedVectorVectorizerWithMultiVectorIndex",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorConfig: map[string]models.VectorConfig{
+						"colbert": {
+							Vectorizer: map[string]interface{}{
+								"text2multivec-jinaai": map[string]interface{}{
+									"vectorizeClassName": false,
+								},
+							},
+							VectorIndexConfig: map[string]interface{}{
+								"multivector": map[string]interface{}{
+									"enabled": false,
+								},
+							},
+							VectorIndexType: "hnsw",
+						},
+					},
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				// Weaviate overrides the multivector setting if it finds that someone has enabled
+				// multi vector vectorizer
+				require.NoError(t, err)
+			})
+			t.Run("named vector is colbert vectorizer with empty vector index", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "NamedVectorVectorizerWithMultiVectorIndex",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorConfig: map[string]models.VectorConfig{
+						"colbert": {
+							Vectorizer: map[string]interface{}{
+								"text2multivec-jinaai": map[string]interface{}{
+									"vectorizeClassName": false,
+								},
+							},
+							VectorIndexType: "hnsw",
+						},
+					},
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				// Weaviate overrides the multivector setting if it finds that someone has enabled
+				// multi vector vectorizer
+				require.NoError(t, err)
+				cls, err := client.Schema().ClassGetter().WithClassName(class.Class).Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, cls.VectorConfig["colbert"])
+				vc := cls.VectorConfig["colbert"].VectorIndexConfig
+				require.NotNil(t, vc)
+				vsAsMap, ok := vc.(map[string]interface{})
+				require.True(t, ok)
+				mv, ok := vsAsMap["multivector"].(map[string]interface{})
+				require.True(t, ok)
+				assert.True(t, mv["enabled"].(bool))
+			})
+			t.Run("multi vector index with flat vector index type", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "NamedVectorVectorizerWithMultiVectorIndex",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorConfig: map[string]models.VectorConfig{
+						"colbert": {
+							Vectorizer: map[string]interface{}{
+								"text2multivec-jinaai": map[string]interface{}{
+									"vectorizeClassName": false,
+								},
+							},
+							VectorIndexType: "flat",
+						},
+					},
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				// Weaviate overrides the multivector setting if it finds that someone has enabled
+				// multi vector vectorizer
+				require.Error(t, err)
+				assert.ErrorContains(t, err, `parse vector index config: multi vector index is not supported for vector index type: \"flat\", only supported type is hnsw`)
+			})
+			t.Run("multi vector index with dynamic vector index type", func(t *testing.T) {
+				cleanup()
+				class := &models.Class{
+					Class: "NamedVectorVectorizerWithMultiVectorIndex",
+					Properties: []*models.Property{
+						{
+							Name: "name", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorConfig: map[string]models.VectorConfig{
+						"colbert": {
+							Vectorizer: map[string]interface{}{
+								"text2multivec-jinaai": map[string]interface{}{
+									"vectorizeClassName": false,
+								},
+							},
+							VectorIndexType: "dynamic",
+						},
+					},
+				}
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				// Weaviate overrides the multivector setting if it finds that someone has enabled
+				// multi vector vectorizer
+				require.Error(t, err)
+
+				if asyncIndexingEnabled {
+					assert.ErrorContains(t, err, `parse vector index config: multi vector index is not supported for vector index type: \"dynamic\", only supported type is hnsw`)
+				} else {
+					assert.ErrorContains(t, err, `the dynamic index can only be created under async indexing environment`)
+				}
+			})
+		})
+
+		t.Run("validate multi vector dimensions", func(t *testing.T) {
+			className := fixtures.BringYourOwnColBERTClassName
+			objects := fixtures.BringYourOwnColBERTObjects
+			byoc := fixtures.BringYourOwnColBERTNamedVectorName
+
+			t.Run("batch create", func(t *testing.T) {
+				cleanup()
+
+				t.Run("create schema", func(t *testing.T) {
+					class := fixtures.BringYourOwnColBERTClass(className)
+					err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+					require.NoError(t, err)
+				})
+
+				t.Run("batch create objects", func(t *testing.T) {
+					obj1 := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(objects[0].ID),
+						Properties: map[string]interface{}{
+							"name": objects[0].Name,
+						},
+						Vectors: models.Vectors{
+							byoc: objects[0].Vector,
+						},
+					}
+					objWrongDimensions := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(objects[1].ID),
+						Properties: map[string]interface{}{
+							"name": objects[1].Name,
+						},
+						Vectors: models.Vectors{
+							byoc: [][]float32{{0.12, 0.12}, {0.11}},
+						},
+					}
+					resp, err := client.Batch().ObjectsBatcher().
+						WithObjects(obj1, objWrongDimensions).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, resp)
+					success, failed := false, false
+					for i := range resp {
+						if *resp[i].Result.Status == "SUCCESS" {
+							success = true
+						}
+						if *resp[i].Result.Status == "FAILED" {
+							failed = true
+						}
+					}
+					assert.True(t, success)
+					assert.True(t, failed)
+				})
+			})
+
+			t.Run("insert", func(t *testing.T) {
+				cleanup()
+
+				t.Run("create schema", func(t *testing.T) {
+					class := fixtures.BringYourOwnColBERTClass(className)
+					err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+					require.NoError(t, err)
+				})
+
+				t.Run("batch create objects", func(t *testing.T) {
+					obj1 := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(objects[0].ID),
+						Properties: map[string]interface{}{
+							"name": objects[0].Name,
+						},
+						Vectors: models.Vectors{
+							byoc: objects[0].Vector,
+						},
+					}
+					resp, err := client.Batch().ObjectsBatcher().
+						WithObjects(obj1).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, resp)
+					require.Equal(t, "SUCCESS", *resp[0].Result.Status)
+				})
+
+				t.Run("insert additional object", func(t *testing.T) {
+					objWrongDimensions := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(objects[1].ID),
+						Properties: map[string]interface{}{
+							"name": objects[1].Name,
+						},
+						Vectors: models.Vectors{
+							byoc: [][]float32{{0.12, 0.12}, {0.11}},
+						},
+					}
+					_, err := client.Data().Creator().
+						WithClassName(objWrongDimensions.Class).
+						WithID(objWrongDimensions.ID.String()).
+						WithProperties(objWrongDimensions.Properties).
+						WithVectors(objWrongDimensions.Vectors).
+						Do(ctx)
+					require.Error(t, err)
+				})
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_generative.go

@@ -0,0 +1,123 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testNamedVectorsWithGenerativeModules(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("named vectors with generative module", func(t *testing.T) {
+			cleanup()
+			// Define class
+			className := "BooksGenerativeTest"
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name: "title", DataType: []string{schema.DataTypeText.String()},
+					},
+					{
+						Name: "description", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					"title": {
+						Vectorizer: map[string]interface{}{
+							"text2vec-model2vec": map[string]interface{}{
+								"properties":         []interface{}{"title"},
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "flat",
+					},
+					"description": {
+						Vectorizer: map[string]interface{}{
+							"text2vec-transformers": map[string]interface{}{
+								"properties":         []interface{}{"description"},
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "flat",
+					},
+				},
+				ModuleConfig: map[string]interface{}{
+					"generative-openai": map[string]interface{}{
+						"model": "gpt-4",
+					},
+				},
+			}
+
+			t.Run("create schema", func(t *testing.T) {
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.NoError(t, err)
+			})
+
+			t.Run("batch create objects", func(t *testing.T) {
+				objs := []*models.Object{}
+				for id, book := range fixtures.Books() {
+					obj := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(id),
+						Properties: map[string]interface{}{
+							"title":       book.Title,
+							"description": book.Description,
+						},
+					}
+					objs = append(objs, obj)
+				}
+
+				resp, err := client.Batch().ObjectsBatcher().
+					WithObjects(objs...).
+					Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+			})
+
+			t.Run("check existence", func(t *testing.T) {
+				for id := range fixtures.Books() {
+					objs, err := client.Data().ObjectsGetter().
+						WithID(id).
+						WithClassName(className).
+						WithVector().
+						Do(ctx)
+					require.NoError(t, err)
+					require.Len(t, objs, 1)
+					require.NotNil(t, objs[0])
+					require.Len(t, objs[0].Vectors, 2)
+					assert.NotEmpty(t, objs[0].Vectors["title"])
+					assert.NotEmpty(t, objs[0].Vectors["description"])
+				}
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_hybrid.go

@@ -0,0 +1,201 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	acceptance_with_go_client "acceptance_tests_with_client"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testHybrid(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		class := &models.Class{
+			Class: "TestClass",
+			Properties: []*models.Property{
+				{
+					Name: "text", DataType: []string{schema.DataTypeText.String()},
+				},
+				{
+					Name: "text2", DataType: []string{schema.DataTypeText.String()},
+				},
+			},
+			VectorConfig: map[string]models.VectorConfig{
+				transformers: {
+					Vectorizer: map[string]interface{}{
+						text2vecTransformers: map[string]interface{}{
+							"vectorizeClassName": false,
+							"sourceProperties":   []string{"text"},
+						},
+					},
+					VectorIndexType: "flat",
+				},
+				model2vec: {
+					Vectorizer: map[string]interface{}{
+						text2vecModel2Vec: map[string]interface{}{
+							"vectorizeClassName": false,
+							"sourceProperties":   []string{"text2"},
+						},
+					},
+					VectorIndexType: "flat",
+				},
+			},
+		}
+
+		cleanup := func() {
+			err := client.Schema().ClassDeleter().WithClassName(class.Class).Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		field := graphql.Field{
+			Name: "_additional",
+			Fields: []graphql.Field{
+				{Name: "id"},
+			},
+		}
+		id := "1aa6fbff-461b-4ca5-9ff7-47ccd6d07519"
+		id2 := "1aa6fbff-463b-4ca5-9ff7-47ccd6d07519"
+
+		t.Run("hybrid with 1 vectorizer", func(t *testing.T) {
+			// create class
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			defer cleanup()
+			require.NoError(t, err)
+			// insert object
+			objWrapper, err := client.Data().Creator().
+				WithClassName(class.Class).
+				WithID(id).
+				WithProperties(map[string]interface{}{
+					"text": "Some text goes here",
+				}).
+				Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, objWrapper)
+			assert.Len(t, objWrapper.Object.Vectors, 2)
+
+			resp, err := client.GraphQL().Get().
+				WithClassName(class.Class).
+				WithHybrid(client.GraphQL().
+					HybridArgumentBuilder().
+					WithQuery("Some text goes here").
+					WithAlpha(0.5).WithTargetVectors(transformers)).
+				WithFields(field).
+				Do(ctx)
+			require.NoError(t, err)
+			ids := acceptance_with_go_client.GetIds(t, resp, class.Class)
+			require.ElementsMatch(t, ids, []string{id})
+		})
+
+		t.Run("hybrid with 2 vectorizers", func(t *testing.T) {
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			defer cleanup()
+			require.NoError(t, err)
+			// insert object
+			objWrapper, err := client.Data().Creator().
+				WithClassName(class.Class).
+				WithID(id).
+				WithProperties(map[string]interface{}{
+					"text":  "apple",
+					"text2": "mountain",
+				}).
+				Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, objWrapper)
+			assert.Len(t, objWrapper.Object.Vectors, 2)
+
+			_, err = client.Data().Creator().
+				WithClassName(class.Class).
+				WithID(id2).
+				WithProperties(map[string]interface{}{
+					"text":  "mountain",
+					"text2": "apple",
+				}).
+				Do(ctx)
+			require.NoError(t, err)
+
+			var ids []string
+			require.Eventually(t, func() bool {
+				resp, err := client.GraphQL().Get().
+					WithClassName(class.Class).
+					WithHybrid(client.GraphQL().
+						HybridArgumentBuilder().
+						WithQuery("apple").
+						WithAlpha(1).WithTargetVectors(transformers, model2vec)).
+					WithFields(field).
+					Do(ctx)
+				require.NoError(t, err)
+				ids = acceptance_with_go_client.GetIds(t, resp, class.Class)
+				return len(ids) == 2
+			}, 5*time.Second, 1*time.Second)
+
+			require.ElementsMatch(t, ids, []string{id, id2})
+		})
+
+		t.Run("default vector chosen", func(t *testing.T) {
+			singleVecClass := &models.Class{
+				Class: "TestClass",
+				Properties: []*models.Property{
+					{
+						Name: "text", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					model2vec: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{},
+						},
+						VectorIndexType: "flat",
+					},
+				},
+			}
+
+			require.NoError(t, client.Schema().ClassCreator().WithClass(singleVecClass).Do(ctx))
+			defer cleanup()
+
+			_, err = client.Data().Creator().
+				WithClassName(class.Class).
+				WithID(id).
+				WithProperties(map[string]interface{}{
+					"text": "Some text goes here",
+				}).
+				Do(ctx)
+			require.NoError(t, err)
+
+			// query without providing target vector
+			resp, err := client.GraphQL().Get().
+				WithClassName(class.Class).
+				WithHybrid(client.GraphQL().
+					HybridArgumentBuilder().
+					WithQuery("Some text goes here").
+					WithAlpha(0.5)).
+				WithFields(field).
+				Do(ctx)
+			require.NoError(t, err)
+
+			ids := acceptance_with_go_client.GetIds(t, resp, class.Class)
+			require.ElementsMatch(t, ids, []string{id})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_objects.go

@@ -0,0 +1,297 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+
+	acceptance_with_go_client "acceptance_tests_with_client"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testCreateObject(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("multiple named vectors", func(t *testing.T) {
+			cleanup()
+
+			t.Run("create schema", func(t *testing.T) {
+				createNamedVectorsClass(t, client)
+			})
+
+			t.Run("create objects", func(t *testing.T) {
+				objects := []struct {
+					id   string
+					text string
+				}{
+					{id: id1, text: "I like reading books"},
+					{id: id2, text: "I like programming"},
+				}
+				for _, object := range objects {
+					objWrapper, err := client.Data().Creator().
+						WithClassName(className).
+						WithID(object.id).
+						WithProperties(map[string]interface{}{
+							"text": object.text,
+						}).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, objWrapper)
+					assert.Len(t, objWrapper.Object.Vectors, len(targetVectors))
+
+					objs, err := client.Data().ObjectsGetter().
+						WithClassName(className).
+						WithID(object.id).
+						WithVector().
+						Do(ctx)
+					require.NoError(t, err)
+					require.Len(t, objs, 1)
+					require.NotNil(t, objs[0])
+					assert.Len(t, objs[0].Vectors, len(targetVectors))
+					properties, ok := objs[0].Properties.(map[string]interface{})
+					require.True(t, ok)
+					assert.Equal(t, object.text, properties["text"])
+				}
+			})
+
+			t.Run("check existence", func(t *testing.T) {
+				for _, id := range []string{id1, id2} {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						Do(ctx)
+					require.NoError(t, err)
+					require.True(t, exists)
+				}
+			})
+
+			t.Run("GraphQL get vectors", func(t *testing.T) {
+				resultVectors := getVectors(t, client, className, id1, targetVectors...)
+				checkTargetVectors(t, resultVectors)
+			})
+
+			t.Run("GraphQL near<Media> check", func(t *testing.T) {
+				for _, targetVector := range targetVectors {
+					nearText := client.GraphQL().NearTextArgBuilder().
+						WithConcepts([]string{"book"}).
+						WithTargetVectors(targetVector)
+					resultVectors := getVectorsWithNearText(t, client, className, id1, nearText, targetVectors...)
+					checkTargetVectors(t, resultVectors)
+				}
+			})
+
+			t.Run("certainty checks", func(t *testing.T) {
+				var vectorM2Vec []float32
+				t.Run("nearText", func(t *testing.T) {
+					nearText := client.GraphQL().NearTextArgBuilder().
+						WithConcepts([]string{"book"}).
+						WithTargetVectors(m2vec)
+					resultVectors := getVectorsWithNearTextWithCertainty(t, client, className, id1, nearText, m2vec)
+					require.NotEmpty(t, resultVectors[m2vec])
+					require.IsType(t, []float32{}, resultVectors[m2vec])
+					vectorM2Vec = resultVectors[m2vec].([]float32)
+				})
+
+				t.Run("nearVector", func(t *testing.T) {
+					nearVector := client.GraphQL().NearVectorArgBuilder().
+						WithVector(vectorM2Vec).
+						WithTargetVectors(m2vec)
+					resultVectors := getVectorsWithNearVectorWithCertainty(t, client, className, id1, nearVector, m2vec)
+					require.NotEmpty(t, resultVectors[m2vec])
+				})
+
+				t.Run("nearObject", func(t *testing.T) {
+					nearObject := client.GraphQL().NearObjectArgBuilder().
+						WithID(id1).
+						WithTargetVectors(m2vec)
+					resultVectors := getVectorsWithNearObjectWithCertainty(t, client, className, id1, nearObject, m2vec)
+					require.NotEmpty(t, resultVectors[m2vec])
+				})
+			})
+
+			t.Run("nearText with certainty limit", func(t *testing.T) {
+				nearText := client.GraphQL().NearTextArgBuilder().
+					WithTargetVectors(m2vec).
+					WithConcepts([]string{"book"}).
+					WithCertainty(0.7)
+
+				res, err := client.GraphQL().Get().
+					WithClassName(className).
+					WithNearText(nearText).
+					WithFields(graphql.Field{
+						Name:   "_additional",
+						Fields: []graphql.Field{{Name: "id"}},
+					}).
+					Do(ctx)
+				require.NoError(t, err)
+				require.Equal(t, []string{id1}, acceptance_with_go_client.GetIds(t, res, className))
+			})
+
+			t.Run("delete 1 object", func(t *testing.T) {
+				err := client.Data().Deleter().
+					WithClassName(className).
+					WithID(id2).
+					Do(ctx)
+				require.NoError(t, err)
+
+				exists, err := client.Data().Checker().
+					WithID(id2).
+					WithClassName(className).
+					Do(ctx)
+				require.NoError(t, err)
+				require.False(t, exists)
+
+				objs, err := client.Data().ObjectsGetter().
+					WithClassName(className).
+					WithID(id1).
+					WithVector().
+					Do(ctx)
+				require.NoError(t, err)
+				require.Len(t, objs, 1)
+				require.NotNil(t, objs[0])
+				assert.Len(t, objs[0].Vectors, len(targetVectors))
+				properties, ok := objs[0].Properties.(map[string]interface{})
+				require.True(t, ok)
+				assert.NotNil(t, properties["text"])
+			})
+
+			t.Run("update object and check if vectors changed", func(t *testing.T) {
+				beforeUpdateVectors := getVectors(t, client, className, id1, targetVectors...)
+				checkTargetVectors(t, beforeUpdateVectors)
+
+				err := client.Data().Updater().
+					WithClassName(className).
+					WithID(id1).
+					WithProperties(map[string]interface{}{
+						"text": "I like reading science-fiction books",
+					}).
+					Do(ctx)
+				require.NoError(t, err)
+				afterUpdateVectors := getVectors(t, client, className, id1, targetVectors...)
+				checkTargetVectors(t, afterUpdateVectors)
+				for _, targetVector := range targetVectors {
+					assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+				}
+			})
+
+			t.Run("merge object and check if vectors changed", func(t *testing.T) {
+				beforeUpdateVectors := getVectors(t, client, className, id1, targetVectors...)
+				checkTargetVectors(t, beforeUpdateVectors)
+
+				err := client.Data().Updater().
+					WithMerge().
+					WithClassName(className).
+					WithID(id1).
+					WithProperties(map[string]interface{}{
+						"text": "This is a new property value that should be merged",
+					}).
+					Do(ctx)
+				require.NoError(t, err)
+				afterUpdateVectors := getVectors(t, client, className, id1, targetVectors...)
+				checkTargetVectors(t, afterUpdateVectors)
+				for _, targetVector := range targetVectors {
+					assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+				}
+			})
+
+			t.Run("add new property", func(t *testing.T) {
+				property := &models.Property{
+					Name:     "dont_vectorize_property",
+					DataType: []string{schema.DataTypeText.String()},
+					ModuleConfig: map[string]interface{}{
+						text2vecModel2Vec: map[string]interface{}{
+							"skip":                  true,
+							"vectorizePropertyName": "false",
+						},
+						text2vecTransformers: map[string]interface{}{
+							"skip":                  true,
+							"vectorizePropertyName": "false",
+						},
+					},
+				}
+
+				err = client.Schema().PropertyCreator().WithClassName(className).WithProperty(property).Do(ctx)
+				require.NoError(t, err)
+
+				class, err := client.Schema().ClassGetter().WithClassName(className).Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, class)
+				require.Len(t, class.Properties, 2)
+
+				beforeUpdateVectors := getVectors(t, client, className, id1, targetVectors...)
+				checkTargetVectors(t, beforeUpdateVectors)
+
+				err = client.Data().Updater().
+					WithMerge().
+					WithClassName(className).
+					WithID(id1).
+					WithProperties(map[string]interface{}{
+						"dont_vectorize_property": "This change should not change vector",
+					}).
+					Do(ctx)
+				require.NoError(t, err)
+				afterUpdateVectors := getVectors(t, client, className, id1, targetVectors...)
+				checkTargetVectors(t, afterUpdateVectors)
+				for _, targetVector := range targetVectors {
+					assert.Equal(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+				}
+			})
+
+			// note that vectors are different afterwards and you cant use checkTargetVectors anymore
+			t.Run("Update with a vector - use the given vector and dont revectorize", func(t *testing.T) {
+				targetVecUpdate := targetVectors[0]
+				beforeUpdateVectors := getVectors(t, client, className, id1, targetVectors...)
+				checkTargetVectors(t, beforeUpdateVectors)
+				require.IsType(t, []float32{}, beforeUpdateVectors[targetVecUpdate])
+				vecForNewObject := make([]float32, len(beforeUpdateVectors[targetVecUpdate].([]float32)))
+				copy(vecForNewObject, beforeUpdateVectors[targetVecUpdate].([]float32))
+				vecForNewObject[0] = vecForNewObject[0] + 0.1
+
+				require.NoError(t, client.Data().Updater().
+					WithMerge().
+					WithClassName(className).
+					WithID(id1).
+					WithProperties(map[string]interface{}{
+						"text": "Apple",
+					}).WithVectors(models.Vectors{targetVecUpdate: vecForNewObject}).
+					Do(ctx))
+
+				// vector from update should be used and it should be different from before
+				afterUpdateVectors := getVectors(t, client, className, id1, targetVectors...)
+				assert.NotEqual(t, beforeUpdateVectors[targetVecUpdate], afterUpdateVectors[targetVecUpdate])
+
+				// no vectorization
+				assert.Equal(t, vecForNewObject, afterUpdateVectors[targetVecUpdate])
+
+				// vectorization for vectors that have not been sent with the update
+				for _, targetVector := range targetVectors[1:] {
+					assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+				}
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_objects_mixed.go

@@ -0,0 +1,265 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/fault"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testCreateSchemaWithMixedVectorizers(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("none vectorizer", func(t *testing.T) {
+			cleanup()
+
+			className := "BringYourOwnVector"
+			none1 := "none1"
+			none2 := "none2"
+			mixedTargetVectors := []string{none1, none2, m2vec, transformers_bq}
+			vector1a := []float32{0.1, 0.2, 0.3}
+			vector2a := []float32{-0.1001, 0.2002, -0.3003, -0.4, -0.5}
+			vector1b := []float32{0.1111, 0.4, 0.3}
+			vector2b := []float32{-0.11, 0.11111, -0.2222, -0.4, -0.5}
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name: "text", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					none1: {
+						Vectorizer: map[string]interface{}{
+							"none": nil,
+						},
+						VectorIndexType: "hnsw",
+					},
+					none2: {
+						Vectorizer: map[string]interface{}{
+							"none": nil,
+						},
+						VectorIndexType: "flat",
+					},
+					m2vec: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+					transformers_bq: {
+						Vectorizer: map[string]interface{}{
+							text2vecTransformers: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType:   "flat",
+						VectorIndexConfig: bqFlatIndexConfig(),
+					},
+				},
+			}
+
+			t.Run("create schema", func(t *testing.T) {
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.NoError(t, err)
+
+				cls, err := client.Schema().ClassGetter().WithClassName(className).Do(ctx)
+				require.NoError(t, err)
+				assert.Equal(t, class.Class, cls.Class)
+				require.NotEmpty(t, cls.VectorConfig)
+				require.Len(t, cls.VectorConfig, len(mixedTargetVectors))
+				for _, targetVector := range mixedTargetVectors {
+					require.NotEmpty(t, cls.VectorConfig[targetVector])
+					assert.NotEmpty(t, cls.VectorConfig[targetVector].VectorIndexType)
+					vectorizerConfig, ok := cls.VectorConfig[targetVector].Vectorizer.(map[string]interface{})
+					require.True(t, ok)
+					assert.Len(t, vectorizerConfig, 1)
+				}
+			})
+
+			t.Run("add objects", func(t *testing.T) {
+				objects := []struct {
+					id      string
+					text    string
+					vectors models.Vectors
+				}{
+					{
+						id:   id1,
+						text: "bring your own first vector",
+						vectors: models.Vectors{
+							none1: vector1a,
+							none2: vector2a,
+						},
+					},
+					{
+						id:   id2,
+						text: "bring your own second vector",
+						vectors: models.Vectors{
+							none1: vector1b,
+							none2: vector2b,
+						},
+					},
+				}
+				for _, tt := range objects {
+					objWrapper, err := client.Data().Creator().
+						WithClassName(className).
+						WithID(tt.id).
+						WithProperties(map[string]interface{}{
+							"text": tt.text,
+						}).
+						WithVectors(tt.vectors).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, objWrapper)
+					assert.Len(t, objWrapper.Object.Vectors, 4)
+
+					objs, err := client.Data().ObjectsGetter().
+						WithClassName(className).
+						WithID(tt.id).
+						WithVector().
+						Do(ctx)
+					require.NoError(t, err)
+					require.Len(t, objs, 1)
+					require.NotNil(t, objs[0])
+					properties, ok := objs[0].Properties.(map[string]interface{})
+					require.True(t, ok)
+					assert.Equal(t, tt.text, properties["text"])
+					assert.Nil(t, objs[0].Vector)
+					assert.Len(t, objs[0].Vectors, len(mixedTargetVectors))
+					for targetVector, vector := range tt.vectors {
+						require.NotNil(t, objs[0].Vectors[targetVector])
+						assert.Equal(t, vector, objs[0].Vectors[targetVector])
+					}
+				}
+			})
+
+			t.Run("update vectors", func(t *testing.T) {
+				beforeUpdateVectors := getVectors(t, client, className, id1, mixedTargetVectors...)
+
+				updatedVector1 := []float32{0.11111111111, 0.2222222222, 0.3333333333}
+				updatedVector2 := []float32{0.1, 0.2, 0.3, 0.4, 0.5}
+				updatedVectors := models.Vectors{
+					none1: updatedVector1,
+					none2: updatedVector2,
+				}
+
+				err := client.Data().Updater().
+					WithClassName(className).
+					WithID(id1).
+					WithVectors(updatedVectors).
+					Do(ctx)
+				require.NoError(t, err)
+				afterUpdateVectors := getVectors(t, client, className, id1, mixedTargetVectors...)
+				for targetVector, vector := range updatedVectors {
+					assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+					assert.Equal(t, vector, models.Vector(afterUpdateVectors[targetVector]))
+				}
+			})
+
+			t.Run("update vectors with merge", func(t *testing.T) {
+				beforeUpdateVectors := getVectors(t, client, className, id1, mixedTargetVectors...)
+
+				updatedVector1 := []float32{0.00001, 0.0002, 0.00003}
+				updatedVector2 := []float32{1.1, 1.2, 1.3, 1.4, 1.5}
+				updatedVectors := models.Vectors{
+					none1: updatedVector1,
+					none2: updatedVector2,
+				}
+
+				err := client.Data().Updater().
+					WithMerge().
+					WithClassName(className).
+					WithID(id1).
+					WithProperties(map[string]interface{}{
+						"text": "This change should change vector",
+					}).
+					WithVectors(updatedVectors).
+					Do(ctx)
+				require.NoError(t, err)
+				afterUpdateVectors := getVectors(t, client, className, id1, mixedTargetVectors...)
+				for _, targetVector := range mixedTargetVectors {
+					assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+				}
+				for targetVector, vector := range updatedVectors {
+					assert.Equal(t, vector, models.Vector(afterUpdateVectors[targetVector]))
+				}
+			})
+
+			t.Run("check BYOV vector names for existence when inserting", func(t *testing.T) {
+				_, err = client.Data().Creator().
+					WithClassName(className).
+					WithID(id3).
+					WithProperties(map[string]interface{}{
+						"text": "Lorem ipsum dolor sit amet",
+					}).
+					WithVectors(models.Vectors{
+						"non_existent_vector": []float32{0.1, 0.2, 0.3},
+					}).
+					Do(ctx)
+				require.Error(t, err)
+				var clientError *fault.WeaviateClientError
+				require.True(t, errors.As(err, &clientError))
+				require.Equal(t, 422, clientError.StatusCode)
+				require.Contains(t, clientError.Msg, fmt.Sprintf("collection %s does not have configuration for vector non_existent_vector", className))
+			})
+
+			t.Run("check BYOV vector names for existence when updating", func(t *testing.T) {
+				err = client.Data().Updater().
+					WithClassName(className).
+					WithID(id1).
+					WithVectors(models.Vectors{
+						"non_existent_vector": []float32{0.1, 0.2, 0.3},
+					}).
+					Do(ctx)
+				require.Error(t, err)
+				var clientError *fault.WeaviateClientError
+				require.True(t, errors.As(err, &clientError))
+				require.Equal(t, 422, clientError.StatusCode)
+				require.Contains(t, clientError.Msg, fmt.Sprintf("collection %s does not have configuration for vector non_existent_vector", className))
+			})
+
+			t.Run("check BYOV vector names for existence when merge updating", func(t *testing.T) {
+				err = client.Data().Updater().WithMerge().
+					WithClassName(className).
+					WithID(id1).
+					WithVectors(models.Vectors{
+						"non_existent_vector": []float32{0.1, 0.2, 0.3},
+					}).
+					Do(ctx)
+				require.Error(t, err)
+				var clientError *fault.WeaviateClientError
+				require.True(t, errors.As(err, &clientError))
+				require.Equal(t, 422, clientError.StatusCode)
+				require.Contains(t, clientError.Msg, fmt.Sprintf("collection %s does not have configuration for vector non_existent_vector", className))
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_objects_none_vectorizer.go

@@ -0,0 +1,236 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testCreateSchemaWithNoneVectorizer(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("none vectorizer", func(t *testing.T) {
+			cleanup()
+
+			className := "BringYourOwnVector"
+			none1 := "none1"
+			none2 := "none2"
+			bringYourTargetVectors := []string{none1, none2}
+			vector1a := []float32{0.1, 0.2, 0.3}
+			vector2a := []float32{-0.1001, 0.2002, -0.3003, -0.4, -0.5}
+			vector1b := []float32{0.1111, 0.4, 0.3}
+			vector2b := []float32{-0.11, 0.11111, -0.2222, -0.4, -0.5}
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name: "text", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					none1: {
+						Vectorizer: map[string]interface{}{
+							"none": nil,
+						},
+						VectorIndexType: "hnsw",
+					},
+					none2: {
+						Vectorizer: map[string]interface{}{
+							"none": nil,
+						},
+						VectorIndexType: "flat",
+					},
+				},
+			}
+
+			t.Run("create schema", func(t *testing.T) {
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.NoError(t, err)
+
+				cls, err := client.Schema().ClassGetter().WithClassName(className).Do(ctx)
+				require.NoError(t, err)
+				assert.Equal(t, class.Class, cls.Class)
+				require.NotEmpty(t, cls.VectorConfig)
+				require.Len(t, cls.VectorConfig, 2)
+				for _, targetVector := range []string{none1, none2} {
+					require.NotEmpty(t, cls.VectorConfig[targetVector])
+					assert.NotEmpty(t, cls.VectorConfig[targetVector].VectorIndexType)
+					vectorizerConfig, ok := cls.VectorConfig[targetVector].Vectorizer.(map[string]interface{})
+					require.True(t, ok)
+					assert.Len(t, vectorizerConfig, 1)
+				}
+			})
+
+			t.Run("add objects", func(t *testing.T) {
+				objects := []struct {
+					id      string
+					text    string
+					vectors models.Vectors
+				}{
+					{
+						id:   id1,
+						text: "bring your own first vector",
+						vectors: models.Vectors{
+							none1: vector1a,
+							none2: vector2a,
+						},
+					},
+					{
+						id:   id2,
+						text: "bring your own second vector",
+						vectors: models.Vectors{
+							none1: vector1b,
+							none2: vector2b,
+						},
+					},
+				}
+				for _, tt := range objects {
+					objWrapper, err := client.Data().Creator().
+						WithClassName(className).
+						WithID(tt.id).
+						WithProperties(map[string]interface{}{
+							"text": tt.text,
+						}).
+						WithVectors(tt.vectors).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, objWrapper)
+					assert.Len(t, objWrapper.Object.Vectors, 2)
+
+					objs, err := client.Data().ObjectsGetter().
+						WithClassName(className).
+						WithID(tt.id).
+						WithVector().
+						Do(ctx)
+					require.NoError(t, err)
+					require.Len(t, objs, 1)
+					require.NotNil(t, objs[0])
+					properties, ok := objs[0].Properties.(map[string]interface{})
+					require.True(t, ok)
+					assert.Equal(t, tt.text, properties["text"])
+					assert.Nil(t, objs[0].Vector)
+					assert.Len(t, objs[0].Vectors, 2)
+					for targetVector, vector := range tt.vectors {
+						require.NotNil(t, objs[0].Vectors[targetVector])
+						assert.Equal(t, vector, objs[0].Vectors[targetVector])
+					}
+				}
+			})
+
+			t.Run("update vectors", func(t *testing.T) {
+				beforeUpdateVectors := getVectors(t, client, className, id1, bringYourTargetVectors...)
+
+				updatedVector1 := []float32{0.11111111111, 0.2222222222, 0.3333333333}
+				updatedVector2 := []float32{0.1, 0.2, 0.3, 0.4, 0.5}
+				updatedVectors := models.Vectors{
+					none1: updatedVector1,
+					none2: updatedVector2,
+				}
+
+				err := client.Data().Updater().
+					WithClassName(className).
+					WithID(id1).
+					WithVectors(updatedVectors).
+					Do(ctx)
+				require.NoError(t, err)
+				afterUpdateVectors := getVectors(t, client, className, id1, bringYourTargetVectors...)
+				for targetVector, vector := range updatedVectors {
+					assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+					assert.Equal(t, vector, models.Vector(afterUpdateVectors[targetVector]))
+				}
+			})
+
+			t.Run("update vectors with merge", func(t *testing.T) {
+				beforeUpdateVectors := getVectors(t, client, className, id1, bringYourTargetVectors...)
+
+				updatedVector1 := []float32{0.00001, 0.0002, 0.00003}
+				updatedVector2 := []float32{1.1, 1.2, 1.3, 1.4, 1.5}
+				updatedVectors := models.Vectors{
+					none1: updatedVector1,
+					none2: updatedVector2,
+				}
+
+				err := client.Data().Updater().
+					WithMerge().
+					WithClassName(className).
+					WithID(id1).
+					WithProperties(map[string]interface{}{
+						"text": "This change should change vector",
+					}).
+					WithVectors(updatedVectors).
+					Do(ctx)
+				require.NoError(t, err)
+				afterUpdateVectors := getVectors(t, client, className, id1, bringYourTargetVectors...)
+				for targetVector, vector := range updatedVectors {
+					assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+					assert.Equal(t, vector, models.Vector(afterUpdateVectors[targetVector]))
+				}
+			})
+
+			t.Run("GraphQL nearVector check", func(t *testing.T) {
+				tests := []struct {
+					targetVector string
+					vector       []float32
+				}{
+					{
+						targetVector: none1,
+						vector:       []float32{0.00001, 0.0002, 0.00003},
+					},
+					{
+						targetVector: none2,
+						vector:       []float32{0.1, 0.2, 0.3, 0.4, 0.5},
+					},
+				}
+				for _, tt := range tests {
+					nearVector := client.GraphQL().NearVectorArgBuilder().
+						WithVector(tt.vector).
+						WithTargetVectors(tt.targetVector)
+					resultVectors := getVectorsWithNearVector(t, client, className, id1, nearVector, bringYourTargetVectors...)
+					for _, targetVector := range bringYourTargetVectors {
+						assert.NotEmpty(t, resultVectors[targetVector])
+					}
+				}
+			})
+
+			t.Run("update without vector", func(t *testing.T) {
+				beforeUpdateVectors := getVectors(t, client, className, id1, none1)
+
+				err := client.Data().Updater().
+					WithMerge().
+					WithClassName(className).
+					WithID(id1).
+					WithProperties(map[string]interface{}{
+						"text": "No vectorizer => Update should reuse old vector",
+					}).
+					Do(ctx)
+				require.NoError(t, err)
+				afterUpdateVectors := getVectors(t, client, className, id1, none1)
+				assert.Equal(t, beforeUpdateVectors[none1], afterUpdateVectors[none1])
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_objects_properties.go

@@ -0,0 +1,231 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testCreateWithModulePropertiesObject(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		author := "author"
+		title := "title"
+		description := "description"
+		genre := "genre"
+
+		targetVectorsWithProperties := []string{
+			author, title, description, genre,
+		}
+
+		t.Run("multiple named vectors", func(t *testing.T) {
+			cleanup()
+
+			t.Run("create schema", func(t *testing.T) {
+				ctx := context.Background()
+				class := &models.Class{
+					Class: className,
+					Properties: []*models.Property{
+						{
+							Name: author, DataType: []string{schema.DataTypeText.String()},
+						},
+						{
+							Name: title, DataType: []string{schema.DataTypeText.String()},
+						},
+						{
+							Name: description, DataType: []string{schema.DataTypeText.String()},
+						},
+						{
+							Name: genre, DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorConfig: map[string]models.VectorConfig{
+						author: {
+							Vectorizer: map[string]interface{}{
+								text2vecModel2Vec: map[string]interface{}{
+									"vectorizeClassName": false,
+									"properties":         []interface{}{"author"},
+								},
+							},
+							VectorIndexType: "hnsw",
+						},
+						title: {
+							Vectorizer: map[string]interface{}{
+								text2vecModel2Vec: map[string]interface{}{
+									"vectorizeClassName": false,
+									"properties":         []interface{}{"title"},
+								},
+							},
+							VectorIndexType: "flat",
+						},
+						description: {
+							Vectorizer: map[string]interface{}{
+								text2vecModel2Vec: map[string]interface{}{
+									"vectorizeClassName": false,
+									"properties":         []interface{}{"description"},
+								},
+							},
+							VectorIndexType:   "hnsw",
+							VectorIndexConfig: pqVectorIndexConfig(),
+						},
+						genre: {
+							Vectorizer: map[string]interface{}{
+								text2vecModel2Vec: map[string]interface{}{
+									"vectorizeClassName": false,
+									"properties":         []interface{}{"genre"},
+								},
+							},
+							VectorIndexType:   "flat",
+							VectorIndexConfig: bqFlatIndexConfig(),
+						},
+					},
+				}
+
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.NoError(t, err)
+
+				cls, err := client.Schema().ClassGetter().WithClassName(className).Do(ctx)
+				require.NoError(t, err)
+				assert.Equal(t, class.Class, cls.Class)
+				require.NotEmpty(t, cls.VectorConfig)
+				require.Len(t, cls.VectorConfig, 4)
+
+				for _, name := range targetVectorsWithProperties {
+					require.NotEmpty(t, cls.VectorConfig[name])
+					assert.Equal(t, class.VectorConfig[name].VectorIndexType, cls.VectorConfig[name].VectorIndexType)
+					vectorizerConfig, ok := cls.VectorConfig[name].Vectorizer.(map[string]interface{})
+					require.True(t, ok)
+					require.NotEmpty(t, vectorizerConfig)
+				}
+			})
+
+			t.Run("create objects", func(t *testing.T) {
+				for id, book := range fixtures.Books() {
+					objWrapper, err := client.Data().Creator().
+						WithClassName(className).
+						WithID(id).
+						WithProperties(map[string]interface{}{
+							author:      book.Author,
+							title:       book.Title,
+							description: book.Description,
+							genre:       book.Genre,
+						}).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, objWrapper)
+					assert.Len(t, objWrapper.Object.Vectors, 4)
+
+					objs, err := client.Data().ObjectsGetter().
+						WithClassName(className).
+						WithID(id).
+						WithVector().
+						Do(ctx)
+					require.NoError(t, err)
+					require.Len(t, objs, 1)
+					require.NotNil(t, objs[0])
+					assert.Len(t, objs[0].Vectors, 4)
+					properties, ok := objs[0].Properties.(map[string]interface{})
+					require.True(t, ok)
+					assert.Equal(t, book.Author, properties["author"])
+					assert.Equal(t, book.Title, properties["title"])
+					assert.Equal(t, book.Description, properties["description"])
+					assert.Equal(t, book.Genre, properties["genre"])
+				}
+			})
+
+			t.Run("check if all objects have been indexed", func(t *testing.T) {
+				testAllObjectsIndexed(t, client, className)
+			})
+
+			t.Run("GraphQL get vectors", func(t *testing.T) {
+				for id := range fixtures.Books() {
+					resultVectors := getVectors(t, client, className, id, targetVectorsWithProperties...)
+					for _, targetVector := range targetVectorsWithProperties {
+						assert.NotEmpty(t, resultVectors[targetVector])
+					}
+				}
+			})
+
+			t.Run("GraphQL near<Media> check", func(t *testing.T) {
+				for id, book := range fixtures.Books() {
+					for _, targetVector := range targetVectorsWithProperties {
+						nearText := client.GraphQL().NearTextArgBuilder().
+							WithConcepts([]string{book.Title}).
+							WithTargetVectors(targetVector)
+						resultVectors := getVectorsWithNearText(t, client, className, id, nearText, targetVectorsWithProperties...)
+						for _, targetVector := range targetVectorsWithProperties {
+							assert.NotEmpty(t, resultVectors[targetVector])
+						}
+					}
+				}
+			})
+
+			t.Run("GraphQL hybrid check", func(t *testing.T) {
+				for _, book := range fixtures.Books() {
+					raw := client.GraphQL().Raw()
+					res, err := raw.WithQuery(fmt.Sprintf(""+
+						"{Get {%s (hybrid: {query: %q targetVectors: %q}){title _additional{id}}}}", className, book.Title, "title")).Do(ctx)
+					require.Nil(t, err)
+					require.NotNil(t, res)
+					require.Nil(t, res.Errors)
+					require.NotNil(t, res.Data)
+					titleHybrid := res.Data["Get"].(map[string]interface{})[className].([]interface{})[0].(map[string]interface{})["title"].(string)
+					require.Equal(t, titleHybrid, book.Title)
+				}
+			})
+			t.Run("merge object and check if vectors changed", func(t *testing.T) {
+				for id, book := range fixtures.Books() {
+					beforeUpdateVectors := getVectors(t, client, className, id, targetVectorsWithProperties...)
+					// change only genre property
+					err := client.Data().Updater().
+						WithMerge().
+						WithClassName(className).
+						WithID(id).
+						WithProperties(map[string]interface{}{
+							author:      book.Author,
+							title:       book.Title,
+							description: book.Description,
+							genre:       fmt.Sprintf("change only in %s genre", book.Genre),
+						}).
+						Do(ctx)
+					require.NoError(t, err)
+					afterUpdateVectors := getVectors(t, client, className, id, targetVectorsWithProperties...)
+					for _, targetVector := range targetVectors {
+						if targetVector == genre {
+							assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+						} else {
+							assert.Equal(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+						}
+					}
+				}
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_ref_props.go

@@ -0,0 +1,288 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/filters"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/usecases/config"
+)
+
+func testReferenceProperties(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+		cleanup()
+
+		classBookshelf := "Bookshelf"
+		classBook := "Book"
+		author := "author"
+		title := "title"
+		description := "description"
+		genre := "genre"
+		ofBookshelf := "ofBookshelf"
+		transformers_bookshelf_name := "transformers_bookshelf_name"
+		m2vec_bookshelf_name := "m2vec_bookshelf_name"
+
+		bookshelfIDs := []string{
+			"00000000-0000-0000-0000-00000000000a",
+			"00000000-0000-0000-0000-00000000000b",
+			"00000000-0000-0000-0000-00000000000c",
+			"00000000-0000-0000-0000-00000000000d",
+		}
+
+		t.Run("create schema", func(t *testing.T) {
+			bookshelf := &models.Class{
+				Class: classBookshelf,
+				Properties: []*models.Property{
+					{
+						Name:     "name",
+						DataType: []string{"text"},
+					},
+				},
+				InvertedIndexConfig: &models.InvertedIndexConfig{IndexTimestamps: true, UsingBlockMaxWAND: config.DefaultUsingBlockMaxWAND},
+				VectorConfig: map[string]models.VectorConfig{
+					m2vec_bookshelf_name: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+								"properties":         []interface{}{"name"},
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+					transformers_bookshelf_name: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+								"properties":         []interface{}{"name"},
+							},
+						},
+						VectorIndexType: "flat",
+					},
+				},
+			}
+			book := &models.Class{
+				Class: classBook,
+				Properties: []*models.Property{
+					{
+						Name: author, DataType: []string{schema.DataTypeText.String()},
+					},
+					{
+						Name: title, DataType: []string{schema.DataTypeText.String()},
+					},
+					{
+						Name: description, DataType: []string{schema.DataTypeText.String()},
+					},
+					{
+						Name: genre, DataType: []string{schema.DataTypeText.String()},
+					},
+					{
+						Name: ofBookshelf, DataType: []string{classBookshelf},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					author: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+								"properties":         []interface{}{author},
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+					title: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+								"properties":         []interface{}{title},
+							},
+						},
+						VectorIndexType: "flat",
+					},
+					description: {
+						Vectorizer: map[string]interface{}{
+							text2vecTransformers: map[string]interface{}{
+								"vectorizeClassName": false,
+								"properties":         []interface{}{description},
+							},
+						},
+						VectorIndexType:   "hnsw",
+						VectorIndexConfig: pqVectorIndexConfig(),
+					},
+					genre: {
+						Vectorizer: map[string]interface{}{
+							text2vecTransformers: map[string]interface{}{
+								"vectorizeClassName": false,
+								"properties":         []interface{}{genre},
+							},
+						},
+						VectorIndexType:   "flat",
+						VectorIndexConfig: bqFlatIndexConfig(),
+					},
+				},
+			}
+			err := client.Schema().ClassCreator().WithClass(bookshelf).Do(ctx)
+			assert.NoError(t, err)
+			err = client.Schema().ClassCreator().WithClass(book).Do(ctx)
+			require.NoError(t, err)
+		})
+
+		t.Run("import data", func(t *testing.T) {
+			bookshelfs := make([]*models.Object, len(bookshelfIDs))
+			for i, id := range bookshelfIDs {
+				bookshelfs[i] = &models.Object{
+					ID:    strfmt.UUID(id),
+					Class: classBookshelf,
+					Properties: map[string]interface{}{
+						"name": fmt.Sprintf("Name of the bookshelf number %v", i),
+					},
+				}
+			}
+			resp, err := client.Batch().ObjectsBatcher().
+				WithObjects(bookshelfs...).
+				Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, resp)
+
+			books := []*models.Object{}
+			for id, book := range fixtures.Books() {
+				books = append(books, &models.Object{
+					ID:    strfmt.UUID(id),
+					Class: classBook,
+					Properties: map[string]interface{}{
+						author:      book.Author,
+						title:       book.Title,
+						description: book.Description,
+						genre:       book.Genre,
+					},
+				})
+			}
+			resp, err = client.Batch().ObjectsBatcher().
+				WithObjects(books...).
+				Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, resp)
+
+			createReferences := func(t *testing.T, client *wvt.Client,
+				bookshelf *models.Object, books []*models.Object,
+			) {
+				ref := client.Data().ReferencePayloadBuilder().
+					WithID(bookshelf.ID.String()).WithClassName(bookshelf.Class).Payload()
+				for _, book := range books {
+					err := client.Data().ReferenceCreator().
+						WithID(book.ID.String()).
+						WithClassName(book.Class).
+						WithReferenceProperty(ofBookshelf).
+						WithReference(ref).
+						Do(context.TODO())
+					assert.Nil(t, err)
+				}
+			}
+
+			createReferences(t, client, bookshelfs[0], books[:10])
+			createReferences(t, client, bookshelfs[1], books[10:])
+		})
+
+		t.Run("GrahQL check", func(t *testing.T) {
+			targetVectors := []string{transformers_bookshelf_name, m2vec_bookshelf_name}
+			where := filters.Where().
+				WithPath([]string{"id"}).
+				WithOperator(filters.Equal).
+				WithValueText(id1)
+			_additional := graphql.Field{
+				Name: "_additional",
+				Fields: []graphql.Field{
+					{Name: "id"},
+					{Name: fmt.Sprintf("vectors{%s}", strings.Join(targetVectors, " "))},
+				},
+			}
+			ofBookshelfField := graphql.Field{
+				Name: ofBookshelf,
+				Fields: []graphql.Field{
+					{
+						Name:   "... on Bookshelf",
+						Fields: []graphql.Field{_additional},
+					},
+				},
+			}
+			resp, err := client.GraphQL().Get().
+				WithClassName(classBook).
+				WithWhere(where).
+				WithFields(ofBookshelfField).
+				Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, resp)
+			require.NotNil(t, resp.Data)
+			require.Empty(t, resp.Errors)
+
+			classMap, ok := resp.Data["Get"].(map[string]interface{})
+			require.True(t, ok)
+
+			class, ok := classMap[classBook].([]interface{})
+			require.True(t, ok)
+
+			targetVectorsMap := make(map[string][]float32)
+			for i := range class {
+				resultMap, ok := class[i].(map[string]interface{})
+				require.True(t, ok)
+
+				refProp, ok := resultMap[ofBookshelf].([]interface{})
+				require.True(t, ok)
+				require.Len(t, refProp, 1)
+
+				aaa, ok := refProp[0].(map[string]interface{})
+				require.True(t, ok)
+
+				additional, ok := aaa["_additional"].(map[string]interface{})
+				require.True(t, ok)
+
+				vectors, ok := additional["vectors"].(map[string]interface{})
+				require.True(t, ok)
+
+				for _, targetVector := range targetVectors {
+					vector, ok := vectors[targetVector].([]interface{})
+					require.True(t, ok)
+
+					vec := make([]float32, len(vector))
+					for i := range vector {
+						vec[i] = float32(vector[i].(float64))
+					}
+
+					targetVectorsMap[targetVector] = vec
+				}
+			}
+			require.Len(t, targetVectorsMap, len(targetVectors))
+			assert.NotEmpty(t, targetVectorsMap[m2vec_bookshelf_name])
+			assert.NotEmpty(t, targetVectorsMap[transformers_bookshelf_name])
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_restart.go

@@ -0,0 +1,123 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/docker"
+)
+
+func TestRestart(compose *docker.DockerCompose) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		host := compose.GetWeaviate().URI()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("multiple named vectors", func(t *testing.T) {
+			cleanup()
+
+			t.Run("create schema", func(t *testing.T) {
+				createNamedVectorsClass(t, client)
+			})
+
+			t.Run("batch create objects", func(t *testing.T) {
+				objs := []*models.Object{}
+				for id, book := range fixtures.Books() {
+					obj := &models.Object{
+						Class: className,
+						ID:    strfmt.UUID(id),
+						Properties: map[string]interface{}{
+							"text": book.Description,
+						},
+					}
+					objs = append(objs, obj)
+				}
+
+				resp, err := client.Batch().ObjectsBatcher().
+					WithObjects(objs...).
+					Do(ctx)
+				require.NoError(t, err)
+				require.NotNil(t, resp)
+			})
+
+			t.Run("check existence", func(t *testing.T) {
+				for id := range fixtures.Books() {
+					exists, err := client.Data().Checker().
+						WithID(id).
+						WithClassName(className).
+						Do(ctx)
+					require.NoError(t, err)
+					require.True(t, exists)
+				}
+			})
+
+			t.Run("check if all objects have been indexed", func(t *testing.T) {
+				testAllObjectsIndexed(t, client, className)
+			})
+
+			t.Run("GraphQL get vectors", func(t *testing.T) {
+				for id := range fixtures.Books() {
+					resultVectors := getVectors(t, client, className, id, targetVectors...)
+					checkTargetVectors(t, resultVectors)
+				}
+			})
+
+			t.Run("GraphQL near<Media> check", func(t *testing.T) {
+				for id, book := range fixtures.Books() {
+					for _, targetVector := range targetVectors {
+						nearText := client.GraphQL().NearTextArgBuilder().
+							WithConcepts([]string{book.Title}).
+							WithTargetVectors(targetVector)
+						resultVectors := getVectorsWithNearText(t, client, className, id, nearText, targetVectors...)
+						checkTargetVectors(t, resultVectors)
+					}
+				}
+			})
+
+			t.Run("GraphQL near<Media> check after restart", func(t *testing.T) {
+				err := compose.Stop(ctx, compose.GetWeaviate().Name(), nil)
+				require.NoError(t, err)
+
+				err = compose.Start(ctx, compose.GetWeaviate().Name())
+				require.NoError(t, err)
+
+				host := compose.GetWeaviate().URI()
+				client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+				require.Nil(t, err)
+
+				for id, book := range fixtures.Books() {
+					for _, targetVector := range targetVectors {
+						nearText := client.GraphQL().NearTextArgBuilder().
+							WithConcepts([]string{book.Title}).
+							WithTargetVectors(targetVector)
+						resultVectors := getVectorsWithNearText(t, client, className, id, nearText, targetVectors...)
+						checkTargetVectors(t, resultVectors)
+					}
+				}
+			})
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_schema.go

@@ -0,0 +1,240 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testCreateSchema(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("one named vector", func(t *testing.T) {
+			cleanup()
+			className := "NamedVector"
+			text2vecOpenAI := "text2vec-openai"
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name: "text", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					"openai": {
+						Vectorizer: map[string]interface{}{
+							text2vecOpenAI: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+				},
+			}
+
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.NoError(t, err)
+
+			cls, err := client.Schema().ClassGetter().WithClassName(className).Do(ctx)
+			require.NoError(t, err)
+			assert.Equal(t, class.Class, cls.Class)
+			require.NotEmpty(t, cls.VectorConfig)
+			require.Len(t, cls.VectorConfig, 1)
+			require.NotEmpty(t, cls.VectorConfig["openai"])
+			assert.Equal(t, class.VectorConfig["openai"].VectorIndexType, cls.VectorConfig["openai"].VectorIndexType)
+			vectorizerConfig, ok := cls.VectorConfig["openai"].Vectorizer.(map[string]interface{})
+			require.True(t, ok)
+			require.NotEmpty(t, vectorizerConfig[text2vecOpenAI])
+		})
+
+		t.Run("multiple named vectors", func(t *testing.T) {
+			cleanup()
+			className := "NamedVectors"
+			name1 := "openai"
+			name2 := "cohere"
+			text2vecOpenAI := "text2vec-openai"
+			text2vecCohere := "text2vec-cohere"
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name: "text", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					name1: {
+						Vectorizer: map[string]interface{}{
+							text2vecOpenAI: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+					name2: {
+						Vectorizer: map[string]interface{}{
+							text2vecCohere: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "flat",
+					},
+				},
+			}
+
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.NoError(t, err)
+
+			cls, err := client.Schema().ClassGetter().WithClassName(className).Do(ctx)
+			require.NoError(t, err)
+			assert.Equal(t, class.Class, cls.Class)
+			require.NotEmpty(t, cls.VectorConfig)
+			require.Len(t, cls.VectorConfig, 2)
+			for _, name := range []string{name1, name2} {
+				require.NotEmpty(t, cls.VectorConfig[name])
+				assert.Equal(t, class.VectorConfig[name].VectorIndexType, cls.VectorConfig[name].VectorIndexType)
+				vectorizerConfig, ok := cls.VectorConfig[name].Vectorizer.(map[string]interface{})
+				require.True(t, ok)
+				vectorizerName := text2vecOpenAI
+				if name == name2 {
+					vectorizerName = text2vecCohere
+				}
+				require.NotEmpty(t, vectorizerConfig[vectorizerName])
+			}
+		})
+
+		t.Run("defaults for vectorizer configs", func(t *testing.T) {
+			cleanup()
+
+			className := "NamedVectorsDefaults"
+			nameOpenAI := "openai"
+			nameCohere := "cohere"
+			text2vecOpenAI := "text2vec-openai"
+			text2vecCohere := "text2vec-cohere"
+
+			vectorizerConfigData := map[string]struct {
+				name         string
+				classOptions []string
+				propOptions  []string
+			}{
+				nameOpenAI: {
+					name:         text2vecOpenAI,
+					classOptions: []string{"vectorizeClassName", "baseURL", "model"},
+					propOptions:  []string{"vectorizePropertyName", "skip"},
+				},
+				nameCohere: {
+					name:         text2vecCohere,
+					classOptions: []string{"vectorizeClassName", "baseUrl", "model", "truncate"},
+					propOptions:  []string{"vectorizePropertyName", "skip"},
+				},
+			}
+
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name:     "text",
+						DataType: schema.DataTypeText.PropString(),
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					nameOpenAI: {
+						VectorIndexType: "hnsw",
+						Vectorizer: map[string]interface{}{
+							text2vecOpenAI: map[string]interface{}{},
+						},
+					},
+					nameCohere: {
+						VectorIndexType: "flat",
+						Vectorizer: map[string]interface{}{
+							text2vecCohere: map[string]interface{}{},
+						},
+					},
+				},
+			}
+
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.NoError(t, err)
+
+			classCreated, err := client.Schema().ClassGetter().WithClassName(className).Do(ctx)
+			require.NoError(t, err)
+			assert.Equal(t, class.Class, classCreated.Class)
+
+			// class defaults
+			require.NotNil(t, classCreated.VectorConfig)
+			require.Len(t, classCreated.VectorConfig, len(vectorizerConfigData))
+			for vectorName, vectorizer := range vectorizerConfigData {
+				require.Contains(t, classCreated.VectorConfig, vectorName)
+
+				vectorConfig := class.VectorConfig[vectorName]
+				vectorConfigCreated := classCreated.VectorConfig[vectorName]
+
+				require.NotNil(t, vectorConfigCreated)
+				assert.Equal(t, vectorConfig.VectorIndexType, vectorConfigCreated.VectorIndexType)
+				assert.NotEmpty(t, vectorConfigCreated.VectorIndexConfig)
+
+				require.NotNil(t, vectorConfigCreated.Vectorizer)
+				vectorizers, ok := vectorConfigCreated.Vectorizer.(map[string]interface{})
+				require.True(t, ok)
+				require.Len(t, vectorizers, 1)
+				require.Contains(t, vectorizers, vectorizer.name)
+				require.NotNil(t, vectorizers[vectorizer.name])
+
+				vectorizerConfig, ok := vectorizers[vectorizer.name].(map[string]interface{})
+				require.True(t, ok)
+				require.Len(t, vectorizerConfig, len(vectorizer.classOptions))
+				for _, classOption := range vectorizer.classOptions {
+					assert.Contains(t, vectorizerConfig, classOption)
+				}
+			}
+			assert.Nil(t, class.ModuleConfig)
+			assert.Empty(t, class.Vectorizer)
+			assert.Empty(t, class.VectorIndexType)
+			assert.Nil(t, class.VectorIndexConfig)
+
+			// props defaults
+			for _, prop := range classCreated.Properties {
+				require.NotNil(t, prop.ModuleConfig)
+
+				propModuleConfig, ok := prop.ModuleConfig.(map[string]interface{})
+				require.True(t, ok)
+				require.Len(t, propModuleConfig, len(vectorizerConfigData))
+
+				for _, vectorizer := range vectorizerConfigData {
+					require.Contains(t, propModuleConfig, vectorizer.name)
+					require.NotNil(t, propModuleConfig[vectorizer.name])
+
+					vectorizerConfig, ok := propModuleConfig[vectorizer.name].(map[string]interface{})
+					require.True(t, ok)
+					require.Len(t, vectorizerConfig, len(vectorizer.propOptions))
+					for _, propOption := range vectorizer.propOptions {
+						assert.Contains(t, vectorizerConfig, propOption)
+					}
+				}
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_schema_validation.go

@@ -0,0 +1,276 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testSchemaValidation(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		t.Run("none existent name of the vectorizer module", func(t *testing.T) {
+			cleanup()
+			className := "NamedVector"
+			nonExistenVectorizer := "non_existent_vectorizer_module"
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name: "text", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					nonExistenVectorizer: {
+						Vectorizer: map[string]interface{}{
+							nonExistenVectorizer: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+				},
+			}
+
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.Error(t, err)
+			assert.ErrorContains(t, err, "vectorizer: no module with name \\\"non_existent_vectorizer_module\\\" present")
+		})
+
+		t.Run("properties check", func(t *testing.T) {
+			cleanup()
+			className := "NamedVector"
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name: "text", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					m2vec: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+								"properties":         []interface{}{"text", 1111},
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+				},
+			}
+
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.Error(t, err)
+			assert.ErrorContains(t, err, "properties field value: 1111 must be a string")
+		})
+
+		t.Run("very long target vector name", func(t *testing.T) {
+			tests := []struct {
+				targetVectorName   string
+				validationErrorMsg string
+			}{
+				{
+					targetVectorName:   fmt.Sprintf("%s1", transformers_bq_very_long_230_chars),
+					validationErrorMsg: "Target vector name should not be longer than 230 characters",
+				},
+				{
+					targetVectorName:   "invalid-characters",
+					validationErrorMsg: "Weaviate target vector names are restricted to valid GraphQL names",
+				},
+			}
+			for _, tt := range tests {
+				cleanup()
+				class := &models.Class{
+					Class: className,
+					Properties: []*models.Property{
+						{
+							Name: "text", DataType: []string{schema.DataTypeText.String()},
+						},
+					},
+					VectorConfig: map[string]models.VectorConfig{
+						tt.targetVectorName: {
+							Vectorizer: map[string]interface{}{
+								text2vecModel2Vec: map[string]interface{}{
+									"vectorizeClassName": false,
+								},
+							},
+							VectorIndexType:   "flat",
+							VectorIndexConfig: bqFlatIndexConfig(),
+						},
+					},
+				}
+
+				err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+				require.Error(t, err)
+				assert.ErrorContains(t, err, tt.validationErrorMsg)
+			}
+		})
+
+		t.Run("default vector", func(t *testing.T) {
+			cleanup()
+			oneTargetVector := "oneTargetVector"
+			class := &models.Class{
+				Class: className,
+				Properties: []*models.Property{
+					{
+						Name: "text", DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					oneTargetVector: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType:   "flat",
+						VectorIndexConfig: bqFlatIndexConfig(),
+					},
+				},
+			}
+
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.NoError(t, err)
+
+			objWrapper, err := client.Data().Creator().
+				WithClassName(className).
+				WithID(id1).
+				WithProperties(map[string]interface{}{
+					"text": "default target vector",
+				}).
+				Do(ctx)
+			require.NoError(t, err)
+			require.NotNil(t, objWrapper)
+			assert.Len(t, objWrapper.Object.Vectors, 1)
+
+			nearTextWithoutTargetVector := client.GraphQL().NearTextArgBuilder().
+				WithConcepts([]string{"book"})
+
+			resultVectors := getVectorsWithNearText(t, client, className, id1, nearTextWithoutTargetVector, oneTargetVector)
+			assert.Len(t, resultVectors, 1)
+		})
+
+		t.Run("generative module wrong configuration - legacy configuration", func(t *testing.T) {
+			class := &models.Class{
+				Class: "GenerativeOpenAIModuleLegacyValidation",
+				Properties: []*models.Property{
+					{
+						Name:     "text",
+						DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				ModuleConfig: map[string]interface{}{
+					"generative-openai": map[string]interface{}{
+						"model": "wrong-model",
+					},
+				},
+				Vectorizer:      text2vecModel2Vec,
+				VectorIndexType: "hnsw",
+			}
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.Error(t, err)
+			assert.ErrorContains(t, err, "wrong OpenAI model name")
+		})
+
+		t.Run("generative module wrong configuration - multiple vectors", func(t *testing.T) {
+			class := &models.Class{
+				Class: "GenerativeOpenAIModuleValidation",
+				Properties: []*models.Property{
+					{
+						Name:     "text",
+						DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					m2vec: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+					transformers_flat: {
+						Vectorizer: map[string]interface{}{
+							text2vecTransformers: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "flat",
+					},
+				},
+				ModuleConfig: map[string]interface{}{
+					"generative-openai": map[string]interface{}{
+						"model": "wrong-model",
+					},
+				},
+			}
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.Error(t, err)
+			assert.ErrorContains(t, err, "wrong OpenAI model name")
+		})
+
+		t.Run("generative module proper configuration - multiple vectors", func(t *testing.T) {
+			class := &models.Class{
+				Class: "GenerativeOpenAIModuleValidationProperConfig",
+				Properties: []*models.Property{
+					{
+						Name:     "text",
+						DataType: []string{schema.DataTypeText.String()},
+					},
+				},
+				VectorConfig: map[string]models.VectorConfig{
+					m2vec: {
+						Vectorizer: map[string]interface{}{
+							text2vecModel2Vec: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "hnsw",
+					},
+					transformers_flat: {
+						Vectorizer: map[string]interface{}{
+							text2vecTransformers: map[string]interface{}{
+								"vectorizeClassName": false,
+							},
+						},
+						VectorIndexType: "flat",
+					},
+				},
+				ModuleConfig: map[string]interface{}{
+					"generative-openai": map[string]interface{}{
+						"model": "gpt-4",
+					},
+				},
+			}
+			err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+			require.NoError(t, err)
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_test_data.go

@@ -0,0 +1,373 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	acceptance_with_go_client "acceptance_tests_with_client"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/filters"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/vectorindex/hnsw"
+)
+
+var (
+	className                           = "NamedVectors"
+	m2vec                               = "m2vec"
+	m2vec_pq                            = "m2vec_pq"
+	m2vec_flat                          = "m2vec_flat"
+	m2vec_bq                            = "m2vec_bq"
+	m2vec_pq_very_long_230_chars        = "m2vec_pq_____bq_b9mgu3N7rCUWufddpfCqaVvr4IUjB9xpMBrmiQFIqyuUxKx5s8wCTD7iWb5gPkwNhECumphBMWXD67G9gvN4CQkylG3bDrR8p9sK02RLOGvE96jcaSKjpZrIRvjJuQliGf8BMNmzXEqH39UWGGt4zPNnZNvdPP6pIzxWG5zNpymGmJJLCHk6yP1eO3QgSdXMt0arzfcrAA1L9uZNIVT7tM"
+	model2vec                           = "model2vec"
+	transformers                        = "transformers"
+	transformers_flat                   = "transformers_flat"
+	transformers_pq                     = "transformers_pq"
+	transformers_bq                     = "transformers_bq"
+	transformers_bq_very_long_230_chars = "transformers_bq_b9mgu3N7rCUWufddpfCqaVvr4IUjB9xpMBrmiQFIqyuUxKx5s8wCTD7iWb5gPkwNhECumphBMWXD67G9gvN4CQkylG3bDrR8p9sK02RLOGvE96jcaSKjpZrIRvjJuQliGf8BMNmzXEqH39UWGGt4zPNnZNvdPP6pIzxWG5zNpymGmJJLCHk6yP1eO3QgSdXMt0arzfcrAA1L9uZNIVT7tM"
+	text2vecModel2Vec                   = "text2vec-model2vec"
+	text2vecTransformers                = "text2vec-transformers"
+	id1                                 = "00000000-0000-0000-0000-000000000001"
+	id2                                 = "00000000-0000-0000-0000-000000000002"
+	id3                                 = "00000000-0000-0000-0000-000000000003"
+)
+
+var targetVectors = []string{
+	m2vec, m2vec_flat, m2vec_pq, m2vec_bq,
+	transformers, transformers_flat, transformers_pq, transformers_bq,
+	transformers_bq_very_long_230_chars, m2vec_pq_very_long_230_chars,
+}
+
+func createNamedVectorsClass(t *testing.T, client *wvt.Client) {
+	ctx := context.Background()
+	class := &models.Class{
+		Class: className,
+		Properties: []*models.Property{
+			{
+				Name: "text", DataType: []string{schema.DataTypeText.String()},
+			},
+		},
+		VectorConfig: map[string]models.VectorConfig{
+			m2vec: {
+				Vectorizer: map[string]interface{}{
+					text2vecModel2Vec: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "hnsw",
+			},
+			m2vec_flat: {
+				Vectorizer: map[string]interface{}{
+					text2vecModel2Vec: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			m2vec_pq: {
+				Vectorizer: map[string]interface{}{
+					text2vecModel2Vec: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType:   "hnsw",
+				VectorIndexConfig: pqVectorIndexConfig(),
+			},
+			m2vec_bq: {
+				Vectorizer: map[string]interface{}{
+					text2vecModel2Vec: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType:   "flat",
+				VectorIndexConfig: bqFlatIndexConfig(),
+			},
+			m2vec_pq_very_long_230_chars: {
+				Vectorizer: map[string]interface{}{
+					text2vecModel2Vec: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType:   "hnsw",
+				VectorIndexConfig: pqVectorIndexConfig(),
+			},
+			transformers: {
+				Vectorizer: map[string]interface{}{
+					text2vecTransformers: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "hnsw",
+			},
+			transformers_flat: {
+				Vectorizer: map[string]interface{}{
+					text2vecTransformers: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType: "flat",
+			},
+			transformers_pq: {
+				Vectorizer: map[string]interface{}{
+					text2vecTransformers: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType:   "hnsw",
+				VectorIndexConfig: pqVectorIndexConfig(),
+			},
+			transformers_bq: {
+				Vectorizer: map[string]interface{}{
+					text2vecTransformers: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType:   "flat",
+				VectorIndexConfig: bqFlatIndexConfig(),
+			},
+			transformers_bq_very_long_230_chars: {
+				Vectorizer: map[string]interface{}{
+					text2vecTransformers: map[string]interface{}{
+						"vectorizeClassName": false,
+					},
+				},
+				VectorIndexType:   "flat",
+				VectorIndexConfig: bqFlatIndexConfig(),
+			},
+		},
+	}
+
+	err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+	require.NoError(t, err)
+
+	cls, err := client.Schema().ClassGetter().WithClassName(className).Do(ctx)
+	require.NoError(t, err)
+	assert.Equal(t, class.Class, cls.Class)
+	require.NotEmpty(t, cls.VectorConfig)
+	require.Len(t, cls.VectorConfig, len(targetVectors))
+	for _, name := range targetVectors {
+		require.NotEmpty(t, cls.VectorConfig[name])
+		assert.Equal(t, class.VectorConfig[name].VectorIndexType, cls.VectorConfig[name].VectorIndexType)
+		vectorizerConfig, ok := cls.VectorConfig[name].Vectorizer.(map[string]interface{})
+		require.True(t, ok)
+		vectorizerName := text2vecModel2Vec
+		if strings.HasPrefix(name, "transformers") {
+			vectorizerName = text2vecTransformers
+		}
+		require.NotEmpty(t, vectorizerConfig[vectorizerName])
+	}
+}
+
+func pqVectorIndexConfig() map[string]interface{} {
+	efConstruction := 64
+	ef := 32
+	maxNeighbors := 32
+	vectorCacheMaxObjects := 10e12
+
+	return map[string]interface{}{
+		"maxConnections":        maxNeighbors,
+		"efConstruction":        efConstruction,
+		"ef":                    ef,
+		"vectorCacheMaxObjects": vectorCacheMaxObjects,
+		"distance":              "l2-squared",
+		"pq": map[string]interface{}{
+			"enabled": true,
+			"encoder": map[string]interface{}{
+				"distribution": hnsw.PQEncoderDistributionNormal,
+				"type":         hnsw.PQEncoderTypeKMeans,
+			},
+		},
+	}
+}
+
+func bqFlatIndexConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"bq": map[string]interface{}{
+			"enabled": true,
+		},
+	}
+}
+
+func sqVectorIndexConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"sq": map[string]interface{}{
+			"enabled":      true,
+			"rescoreLimit": -1,
+			"cache":        true,
+		},
+	}
+}
+
+func getVectorsWithNearText(t *testing.T, client *wvt.Client,
+	className, id string, nearText *graphql.NearTextArgumentBuilder, targetVectors ...string,
+) map[string]models.Vector {
+	return getVectorsWithNearArgs(t, client, className, id, nearText, nil, nil, nil, false, targetVectors...)
+}
+
+func getVectorsWithNearTextWithCertainty(t *testing.T, client *wvt.Client,
+	className, id string, nearText *graphql.NearTextArgumentBuilder, targetVectors ...string,
+) map[string]models.Vector {
+	return getVectorsWithNearArgs(t, client, className, id, nearText, nil, nil, nil, true, targetVectors...)
+}
+
+func getVectorsWithNearVector(t *testing.T, client *wvt.Client,
+	className, id string, nearVector *graphql.NearVectorArgumentBuilder, targetVectors ...string,
+) map[string]models.Vector {
+	return getVectorsWithNearArgs(t, client, className, id, nil, nearVector, nil, nil, false, targetVectors...)
+}
+
+func getVectorsWithNearVectorWithCertainty(t *testing.T, client *wvt.Client,
+	className, id string, nearVector *graphql.NearVectorArgumentBuilder, targetVectors ...string,
+) map[string]models.Vector {
+	return getVectorsWithNearArgs(t, client, className, id, nil, nearVector, nil, nil, true, targetVectors...)
+}
+
+func getVectorsWithNearObjectWithCertainty(t *testing.T, client *wvt.Client,
+	className, id string, nearObject *graphql.NearObjectArgumentBuilder, targetVectors ...string,
+) map[string]models.Vector {
+	return getVectorsWithNearArgs(t, client, className, id, nil, nil, nearObject, nil, true, targetVectors...)
+}
+
+func getVectorsWithNearArgs(t *testing.T, client *wvt.Client,
+	className, id string,
+	nearText *graphql.NearTextArgumentBuilder,
+	nearVector *graphql.NearVectorArgumentBuilder,
+	nearObject *graphql.NearObjectArgumentBuilder,
+	hybrid *graphql.HybridArgumentBuilder,
+	withCertainty bool,
+	targetVectors ...string,
+) map[string]models.Vector {
+	where := filters.Where().
+		WithPath([]string{"id"}).
+		WithOperator(filters.Equal).
+		WithValueText(id)
+	field := graphql.Field{
+		Name: "_additional",
+		Fields: []graphql.Field{
+			{Name: "id"},
+		},
+	}
+
+	var (
+		requireLegacyVector   bool
+		filteredTargetVectors []string
+	)
+	for _, targetVector := range targetVectors {
+		if targetVector == "" {
+			requireLegacyVector = true
+		} else {
+			filteredTargetVectors = append(filteredTargetVectors, targetVector)
+		}
+	}
+
+	if requireLegacyVector {
+		field.Fields = append(field.Fields, graphql.Field{Name: "vector"})
+	}
+
+	if len(filteredTargetVectors) > 0 {
+		vectors := fmt.Sprintf("vectors{%s}", strings.Join(filteredTargetVectors, " "))
+		field.Fields = append(field.Fields, graphql.Field{Name: vectors})
+	}
+
+	if withCertainty {
+		field.Fields = append(field.Fields, graphql.Field{Name: "certainty"})
+	}
+	get := client.GraphQL().Get().
+		WithClassName(className).
+		WithWhere(where).
+		WithNearText(nearText).
+		WithFields(field)
+
+	if nearText != nil {
+		get = get.WithNearText(nearText)
+	}
+	if nearVector != nil {
+		get = get.WithNearVector(nearVector)
+	}
+	if nearObject != nil {
+		get = get.WithNearObject(nearObject)
+	}
+	if hybrid != nil {
+		get = get.WithHybrid(hybrid)
+	}
+
+	var resp *models.GraphQLResponse
+	var err error
+
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		resp, err = get.Do(context.Background())
+		require.NoError(t, err)
+		require.NotNil(t, resp)
+		if len(resp.Data) == 0 {
+			return
+		}
+
+		ids := acceptance_with_go_client.GetIds(t, resp, className)
+		assert.Contains(ct, ids, id)
+	}, 5*time.Second, 1*time.Millisecond)
+
+	return acceptance_with_go_client.GetVectors(t, resp, className, withCertainty, targetVectors...)
+}
+
+func getVectors(t *testing.T, client *wvt.Client,
+	className, id string, targetVectors ...string,
+) map[string]models.Vector {
+	return getVectorsWithNearText(t, client, className, id, nil, targetVectors...)
+}
+
+func checkTargetVectors(t *testing.T, resultVectors map[string]models.Vector) {
+	require.NotEmpty(t, resultVectors[m2vec])
+	require.NotEmpty(t, resultVectors[m2vec_flat])
+	require.NotEmpty(t, resultVectors[m2vec_pq])
+	require.NotEmpty(t, resultVectors[m2vec_bq])
+	require.NotEmpty(t, resultVectors[transformers])
+	require.NotEmpty(t, resultVectors[transformers_flat])
+	require.NotEmpty(t, resultVectors[transformers_pq])
+	require.NotEmpty(t, resultVectors[transformers_bq])
+	assert.Equal(t, resultVectors[m2vec], resultVectors[m2vec_flat])
+	assert.Equal(t, resultVectors[m2vec_flat], resultVectors[m2vec_pq])
+	assert.Equal(t, resultVectors[m2vec_pq], resultVectors[m2vec_bq])
+	assert.Equal(t, resultVectors[transformers], resultVectors[transformers_flat])
+	assert.Equal(t, resultVectors[transformers_flat], resultVectors[transformers_pq])
+	assert.Equal(t, resultVectors[transformers_pq], resultVectors[transformers_bq])
+	assert.NotEqual(t, resultVectors[m2vec], resultVectors[transformers])
+	assert.NotEqual(t, resultVectors[m2vec_flat], resultVectors[transformers_flat])
+	assert.NotEqual(t, resultVectors[m2vec_pq], resultVectors[transformers_pq])
+	assert.NotEqual(t, resultVectors[m2vec_bq], resultVectors[transformers_bq])
+}
+
+func testAllObjectsIndexed(t *testing.T, client *wvt.Client, className string) {
+	// wait for all of the objects to get indexed
+	assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+		resp, err := client.Cluster().NodesStatusGetter().
+			WithClass(className).
+			WithOutput("verbose").
+			Do(context.Background())
+		require.NoError(ct, err)
+		require.NotEmpty(ct, resp.Nodes)
+		for _, n := range resp.Nodes {
+			require.NotEmpty(ct, n.Shards)
+			for _, s := range n.Shards {
+				assert.Equal(ct, "READY", s.VectorIndexingStatus)
+			}
+		}
+	}, 30*time.Second, 500*time.Millisecond)
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_go_client/named_vectors_tests/test_suits/named_vectors_vector_index_types.go

@@ -0,0 +1,290 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test_suits
+
+import (
+	"context"
+	"testing"
+
+	"acceptance_tests_with_client/fixtures"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	wvt "github.com/weaviate/weaviate-go-client/v5/weaviate"
+	"github.com/weaviate/weaviate-go-client/v5/weaviate/filters"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testVectorIndexTypesConfigurations(host string) func(t *testing.T) {
+	return func(t *testing.T) {
+		ctx := context.Background()
+		vectorIndexTypeClassName := "NamedVectorsWithVectorIndexType"
+		vectorIndexTargetVectors := []string{"description"}
+		client, err := wvt.NewClient(wvt.Config{Scheme: "http", Host: host})
+		require.Nil(t, err)
+
+		cleanup := func() {
+			err := client.Schema().AllDeleter().Do(context.Background())
+			require.Nil(t, err)
+		}
+
+		idsToDelete := []string{id1, id2}
+		hasBeenDeleted := func(id string) bool {
+			for _, deletedId := range idsToDelete {
+				if deletedId == id {
+					return true
+				}
+			}
+			return false
+		}
+
+		tests := []struct {
+			name              string
+			vectorIndexType   string
+			vectorIndexConfig map[string]interface{}
+		}{
+			{
+				name:              "flat",
+				vectorIndexType:   "flat",
+				vectorIndexConfig: nil,
+			},
+			{
+				name:              "flat_bq",
+				vectorIndexType:   "flat",
+				vectorIndexConfig: bqFlatIndexConfig(),
+			},
+			{
+				name:              "hnsw",
+				vectorIndexType:   "hnsw",
+				vectorIndexConfig: nil,
+			},
+			{
+				name:              "hnsw_pq",
+				vectorIndexType:   "hnsw",
+				vectorIndexConfig: pqVectorIndexConfig(),
+			},
+			{
+				name:              "hnsw_sq",
+				vectorIndexType:   "hnsw",
+				vectorIndexConfig: sqVectorIndexConfig(),
+			},
+			{
+				name:              "hnsw_bq",
+				vectorIndexType:   "hnsw",
+				vectorIndexConfig: bqFlatIndexConfig(),
+			},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				cleanup()
+
+				t.Run("create schema", func(t *testing.T) {
+					ctx := context.Background()
+					class := &models.Class{
+						Class: vectorIndexTypeClassName,
+						Properties: []*models.Property{
+							{
+								Name: "author", DataType: []string{schema.DataTypeText.String()},
+							},
+							{
+								Name: "title", DataType: []string{schema.DataTypeText.String()},
+							},
+							{
+								Name: "description", DataType: []string{schema.DataTypeText.String()},
+							},
+							{
+								Name: "genre", DataType: []string{schema.DataTypeText.String()},
+							},
+						},
+						VectorConfig: map[string]models.VectorConfig{
+							vectorIndexTargetVectors[0]: {
+								Vectorizer: map[string]interface{}{
+									text2vecTransformers: map[string]interface{}{
+										"vectorizeClassName": false,
+										"properties":         []interface{}{"description"},
+									},
+								},
+								VectorIndexType:   tt.vectorIndexType,
+								VectorIndexConfig: tt.vectorIndexConfig,
+							},
+						},
+					}
+
+					err := client.Schema().ClassCreator().WithClass(class).Do(ctx)
+					require.NoError(t, err)
+
+					cls, err := client.Schema().ClassGetter().WithClassName(vectorIndexTypeClassName).Do(ctx)
+					require.NoError(t, err)
+					assert.Equal(t, class.Class, cls.Class)
+					require.NotEmpty(t, cls.VectorConfig)
+					require.Len(t, cls.VectorConfig, len(vectorIndexTargetVectors))
+					for _, name := range vectorIndexTargetVectors {
+						require.NotEmpty(t, cls.VectorConfig[name])
+						assert.Equal(t, class.VectorConfig[name].VectorIndexType, cls.VectorConfig[name].VectorIndexType)
+						vectorizerConfig, ok := cls.VectorConfig[name].Vectorizer.(map[string]interface{})
+						require.True(t, ok)
+						require.NotEmpty(t, vectorizerConfig[text2vecTransformers])
+					}
+				})
+
+				t.Run("batch create objects", func(t *testing.T) {
+					objs := []*models.Object{}
+					for id, book := range fixtures.Books() {
+						obj := &models.Object{
+							Class: vectorIndexTypeClassName,
+							ID:    strfmt.UUID(id),
+							Properties: map[string]interface{}{
+								"author":      book.Author,
+								"title":       book.Title,
+								"description": book.Description,
+								"genre":       book.Genre,
+							},
+						}
+						objs = append(objs, obj)
+					}
+
+					resp, err := client.Batch().ObjectsBatcher().
+						WithObjects(objs...).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, resp)
+				})
+
+				t.Run("check existence", func(t *testing.T) {
+					for id := range fixtures.Books() {
+						exists, err := client.Data().Checker().
+							WithID(id).
+							WithClassName(vectorIndexTypeClassName).
+							Do(ctx)
+						require.NoError(t, err)
+						require.True(t, exists)
+					}
+				})
+
+				t.Run("GraphQL get vectors", func(t *testing.T) {
+					for id := range fixtures.Books() {
+						resultVectors := getVectors(t, client, vectorIndexTypeClassName, id, vectorIndexTargetVectors...)
+						require.NotEmpty(t, resultVectors[vectorIndexTargetVectors[0]])
+					}
+				})
+
+				t.Run("GraphQL near<Media> check", func(t *testing.T) {
+					for id, book := range fixtures.Books() {
+						for _, targetVector := range vectorIndexTargetVectors {
+							nearText := client.GraphQL().NearTextArgBuilder().
+								WithConcepts([]string{book.Title}).
+								WithTargetVectors(targetVector)
+							resultVectors := getVectorsWithNearText(t, client, vectorIndexTypeClassName, id, nearText, vectorIndexTargetVectors...)
+							require.NotEmpty(t, resultVectors[vectorIndexTargetVectors[0]])
+						}
+					}
+				})
+
+				t.Run("batch delete objects", func(t *testing.T) {
+					where := filters.Where().
+						WithPath([]string{"id"}).
+						WithOperator(filters.ContainsAny).
+						WithValueText(idsToDelete...)
+					resp, err := client.Batch().ObjectsBatchDeleter().
+						WithClassName(vectorIndexTypeClassName).
+						WithDryRun(true).
+						WithOutput("verbose").
+						WithWhere(where).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, resp)
+					require.NotNil(t, resp.Results)
+					require.Len(t, resp.Results.Objects, 2)
+					for _, res := range resp.Results.Objects {
+						require.Nil(t, res.Errors)
+						require.NotNil(t, res.Status)
+						assert.Equal(t, models.BatchDeleteResponseResultsObjectsItems0StatusDRYRUN, *res.Status)
+					}
+
+					resp, err = client.Batch().ObjectsBatchDeleter().
+						WithClassName(vectorIndexTypeClassName).
+						WithDryRun(false).
+						WithOutput("verbose").
+						WithWhere(where).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, resp)
+					require.NotNil(t, resp.Results)
+					require.Len(t, resp.Results.Objects, 2)
+					for _, res := range resp.Results.Objects {
+						require.Nil(t, res.Errors)
+						require.NotNil(t, res.Status)
+						assert.Equal(t, models.BatchDeleteResponseResultsObjectsItems0StatusSUCCESS, *res.Status)
+					}
+
+					for id := range fixtures.Books() {
+						exists, err := client.Data().Checker().
+							WithID(id).
+							WithClassName(vectorIndexTypeClassName).
+							Do(ctx)
+						require.NoError(t, err)
+						isDeleted := false
+						for _, deletedID := range idsToDelete {
+							if id == deletedID {
+								isDeleted = true
+								break
+							}
+						}
+						require.Equal(t, !isDeleted, exists)
+					}
+				})
+
+				t.Run("batch update objects and check if vectors changed", func(t *testing.T) {
+					existingIds := []string{}
+					for id := range fixtures.Books() {
+						if !hasBeenDeleted(id) {
+							existingIds = append(existingIds, id)
+						}
+					}
+					beforeUpdateVectorsMap := map[string]map[string][]float32{}
+					for _, id := range existingIds {
+						beforeUpdateVectors := getVectors(t, client, vectorIndexTypeClassName, id, vectorIndexTargetVectors...)
+						require.NotEmpty(t, beforeUpdateVectors[vectorIndexTargetVectors[0]])
+					}
+
+					objs := []*models.Object{}
+					for id, book := range fixtures.Books() {
+						obj := &models.Object{
+							Class: vectorIndexTypeClassName,
+							ID:    strfmt.UUID(id),
+							Properties: map[string]interface{}{
+								"description": book.Title,
+							},
+						}
+						objs = append(objs, obj)
+					}
+					resp, err := client.Batch().ObjectsBatcher().
+						WithObjects(objs...).
+						Do(ctx)
+					require.NoError(t, err)
+					require.NotNil(t, resp)
+
+					for _, id := range existingIds {
+						afterUpdateVectors := getVectors(t, client, vectorIndexTypeClassName, id, vectorIndexTargetVectors...)
+						require.NotEmpty(t, afterUpdateVectors[vectorIndexTargetVectors[0]])
+						beforeUpdateVectors := beforeUpdateVectorsMap[id]
+						for _, targetVector := range vectorIndexTargetVectors {
+							assert.NotEqual(t, beforeUpdateVectors[targetVector], afterUpdateVectors[targetVector])
+						}
+					}
+				})
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance_with_python/bench/test_named_vectors.py

@@ -0,0 +1,58 @@
+import random
+
+import pytest
+from typing_extensions import Any, List
+from weaviate.collections.classes.data import DataObject
+
+from ..conftest import NamedCollection
+
+# run with
+# pytest test/acceptance_with_python/bench/test_named_vectors.py --benchmark-only --benchmark-disable-gc
+
+
+def compute_vectors():
+    # seed with same number to keep reproducible - this is only used to shuffle vectors
+    random.seed(4)
+    base_vector = [0.01 * i for i in range(100)]
+
+    def shuffle(input: List[float]) -> List[float]:
+        random.shuffle(input)
+        return input
+
+    return [shuffle(base_vector) for _ in range(1500)]
+
+
+# precompute outside of benchmark so that this does not change the measured times
+
+INPUT_VECTORS = compute_vectors()
+
+
+def named_vectors(named_collection: NamedCollection, num_targets: int) -> None:
+    collection = named_collection()
+    target_vectors = ["All", "title1", "title2"]
+
+    num_objects = 100
+    ret = collection.data.insert_many(
+        [
+            DataObject(
+                vector={
+                    "All": INPUT_VECTORS[i * 3],
+                    "title1": INPUT_VECTORS[i * 3 + 1],
+                    "title2": INPUT_VECTORS[i * 3 + 2],
+                }
+            )
+            for i in range(num_objects)
+        ]
+    )
+    assert not ret.has_errors
+
+    query_vecs = INPUT_VECTORS[num_objects * 3 :]
+    for j in range(len(query_vecs)):
+        collection.query.near_vector(query_vecs[j], target_vector=target_vectors[:num_targets])
+
+
+@pytest.mark.parametrize("num_targets", [1, 2, 3])
+def test_benchmark_named_vectors(
+    benchmark: Any, named_collection: NamedCollection, num_targets: int
+) -> None:
+    benchmark(named_vectors, named_collection, num_targets)