Add support for nearVector queries with ColBERT

test/graphql/multi_target_search_test.go

@@ -184,7 +184,7 @@ func TestMultiTargetNearVector(t *testing.T) {
 			mta  *graphql.MultiTargetArgumentBuilder
 		}{
 			{name: "with vector", nva: client.GraphQL().NearVectorArgBuilder().WithVector([]float32{1, 0, 0}), mta: to.mta},
-			{name: "with vector per target", nva: client.GraphQL().NearVectorArgBuilder().WithVectorPerTarget(map[string][]float32{"first": {1, 0, 0}, "second": {1, 0, 0}}), mta: to.mta},
+			{name: "with vector per target", nva: client.GraphQL().NearVectorArgBuilder().WithVectorPerTarget(map[string]models.Vector{"first": []float32{1, 0, 0}, "second": []float32{1, 0, 0}}), mta: to.mta},
 		}
 		for _, ti := range inner {
 			t.Run(to.name+" combination "+ti.name, func(t *testing.T) {
@@ -247,7 +247,7 @@ func TestMultiTargetNearVectorMultipleVectors(t *testing.T) {
 	for _, to := range outer {
 		t.Run(to.name+" combination", func(t *testing.T) {
 			nv := &graphql.NearVectorArgumentBuilder{}
-			nv.WithVectorsPerTarget(map[string][][]float32{"first": {{1, 0, 0}, {0, 1, 0}}, "second": {{1, 0, 0}}}).WithTargets(to.mta)
+			nv.WithVectorsPerTarget(map[string][]models.Vector{"first": {[]float32{1, 0, 0}, []float32{0, 1, 0}}, "second": {[]float32{1, 0, 0}}}).WithTargets(to.mta)
 			resp, err := client.GraphQL().Get().WithNearVector(nv).WithClassName(class.Class).WithFields(graphql.Field{Name: "_additional", Fields: []graphql.Field{{Name: "id"}, {Name: "distance"}}}).Do(ctx)
 			require.Nil(t, err)
 			if resp.Errors != nil {

weaviate/graphql/nearvectorbuilder.go

@@ -4,11 +4,13 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+
+	"github.com/weaviate/weaviate/entities/models"
 )
 
 type NearVectorArgumentBuilder struct {
-	vector           []float32
-	vectorsPerTarget map[string][][]float32
+	vector           models.Vector
+	vectorsPerTarget map[string][]models.Vector
 	withCertainty    bool
 	certainty        float32
 	withDistance     bool
@@ -18,18 +20,18 @@ type NearVectorArgumentBuilder struct {
 }
 
 // WithVector sets the search vector to be used in query
-func (b *NearVectorArgumentBuilder) WithVector(vector []float32) *NearVectorArgumentBuilder {
+func (b *NearVectorArgumentBuilder) WithVector(vector models.Vector) *NearVectorArgumentBuilder {
 	b.vector = vector
 	return b
 }
 
 // WithVectorPerTarget sets the search vector per target to be used in a multi target search query. This builder method takes
 // precedence over WithVector. So if WithVectorPerTarget is used, WithVector will be ignored.
-func (b *NearVectorArgumentBuilder) WithVectorPerTarget(vectorPerTarget map[string][]float32) *NearVectorArgumentBuilder {
+func (b *NearVectorArgumentBuilder) WithVectorPerTarget(vectorPerTarget map[string]models.Vector) *NearVectorArgumentBuilder {
 	if len(vectorPerTarget) > 0 {
-		vectorPerTargetTmp := make(map[string][][]float32)
+		vectorPerTargetTmp := make(map[string][]models.Vector)
 		for k, v := range vectorPerTarget {
-			vectorPerTargetTmp[k] = [][]float32{v}
+			vectorPerTargetTmp[k] = []models.Vector{v}
 		}
 		b.vectorsPerTarget = vectorPerTargetTmp
 	}
@@ -38,7 +40,7 @@ func (b *NearVectorArgumentBuilder) WithVectorPerTarget(vectorPerTarget map[stri
 
 // WithVectorsPerTarget sets the search vector per target to be used in a multi target search query. This builder method takes
 // precedence over WithVector and WithVectorPerTarget. So if WithVectorsPerTarget is used, WithVector and WithVectorPerTarget will be ignored.
-func (b *NearVectorArgumentBuilder) WithVectorsPerTarget(vectorPerTarget map[string][][]float32) *NearVectorArgumentBuilder {
+func (b *NearVectorArgumentBuilder) WithVectorsPerTarget(vectorPerTarget map[string][]models.Vector) *NearVectorArgumentBuilder {
 	if len(vectorPerTarget) > 0 {
 		b.vectorsPerTarget = vectorPerTarget
 	}
@@ -95,7 +97,7 @@ func (b *NearVectorArgumentBuilder) build() string {
 		}
 		clause = append(clause, fmt.Sprintf("vectorPerTarget: {%s}", strings.Join(vectorPerTarget, ",")))
 	}
-	if len(b.vector) != 0 && len(b.vectorsPerTarget) == 0 {
+	if !b.isVectorEmpty(b.vector) && len(b.vectorsPerTarget) == 0 {
 		vectorB, err := json.Marshal(b.vector)
 		if err != nil {
 			panic(fmt.Errorf("failed to unmarshal nearVector search vector: %s", err))
@@ -114,6 +116,17 @@ func (b *NearVectorArgumentBuilder) build() string {
 	return fmt.Sprintf("nearVector:{%v}", strings.Join(clause, " "))
 }
 
+func (b *NearVectorArgumentBuilder) isVectorEmpty(vector models.Vector) bool {
+	switch v := vector.(type) {
+	case []float32:
+		return len(v) == 0
+	case [][]float32:
+		return len(v) == 0
+	default:
+		return false
+	}
+}
+
 // prepareTargetVectors adds appends the target name for each target vector associated with it.
 // Example:
 //

weaviate/graphql/nearvectorbuilder_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
 )
 
 func TestNearMultiVectorBuilder_build(t *testing.T) {
@@ -23,7 +24,7 @@ func TestNearMultiVectorBuilder_build(t *testing.T) {
 	t.Run("Average combination with vector per target", func(t *testing.T) {
 		vector := NearVectorArgumentBuilder{}
 		targets := MultiTargetArgumentBuilder{}
-		str := vector.WithVectorPerTarget(map[string][]float32{"one": {1, 2, 3}, "two": {4, 5, 6}}).WithTargets(targets.Average("one", "two")).build()
+		str := vector.WithVectorPerTarget(map[string]models.Vector{"one": []float32{1, 2, 3}, "two": []float32{4, 5, 6}}).WithTargets(targets.Average("one", "two")).build()
 		require.Contains(t, str, "vectorPerTarget: ")
 		require.NotContains(t, str, "vector: ")
 		require.Contains(t, str, "one: [[1,2,3]]")
@@ -78,7 +79,7 @@ func TestNearMultiVectorBuilder_build(t *testing.T) {
 
 	t.Run("No combination with vector per target", func(t *testing.T) {
 		vector := NearVectorArgumentBuilder{}
-		str := vector.WithVectorPerTarget(map[string][]float32{"one": {1, 2, 3}, "two": {4, 5, 6}}).build()
+		str := vector.WithVectorPerTarget(map[string]models.Vector{"one": []float32{1, 2, 3}, "two": []float32{4, 5, 6}}).build()
 		require.Contains(t, str, "vectorPerTarget: ")
 		require.Contains(t, str, "one: [[1,2,3]]")
 		require.Contains(t, str, "two: [[4,5,6]]")
@@ -89,7 +90,7 @@ func TestNearMultiVectorBuilder_build(t *testing.T) {
 
 	t.Run("No combination with multiple vectors per target", func(t *testing.T) {
 		vector := NearVectorArgumentBuilder{}
-		str := vector.WithVectorsPerTarget(map[string][][]float32{"one": {{1, 2, 3}, {7, 8, 9}}, "two": {{4, 5, 6}}}).build()
+		str := vector.WithVectorsPerTarget(map[string][]models.Vector{"one": []models.Vector{[]float32{1, 2, 3}, []float32{7, 8, 9}}, "two": []models.Vector{[]float32{4, 5, 6}}}).build()
 		require.Contains(t, str, "vectorPerTarget: ")
 		require.Contains(t, str, "one: [[1,2,3],[7,8,9]]")
 		require.Contains(t, str, "two: [[4,5,6]]")
@@ -100,9 +101,9 @@ func TestNearMultiVectorBuilder_build(t *testing.T) {
 
 	t.Run("No combination with vector per target and target vectors", func(t *testing.T) {
 		vector := NearVectorArgumentBuilder{}
-		str := vector.WithVectorsPerTarget(map[string][][]float32{
-			"one": {{1, 2, 3}, {7, 8, 9}},
-			"two": {{4, 5, 6}},
+		str := vector.WithVectorsPerTarget(map[string][]models.Vector{
+			"one": {[]float32{1, 2, 3}, []float32{7, 8, 9}},
+			"two": {[]float32{4, 5, 6}},
 		},
 		).WithTargetVectors("one", "two").build()
 		require.Contains(t, str, "vectorPerTarget: ")