restore

modules/text2vec-transformers/clients/meta.go

@@ -0,0 +1,105 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package clients
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"sync"
+
+	"github.com/pkg/errors"
+)
+
+func (v *vectorizer) MetaInfo() (map[string]interface{}, error) {
+	type nameMetaErr struct {
+		name string
+		meta map[string]interface{}
+		err  error
+	}
+
+	endpoints := map[string]string{}
+	if v.originPassage != v.originQuery {
+		endpoints["passage"] = v.urlPassage("/meta")
+		endpoints["query"] = v.urlQuery("/meta")
+	} else {
+		endpoints[""] = v.urlPassage("/meta")
+	}
+
+	var wg sync.WaitGroup
+	ch := make(chan nameMetaErr, len(endpoints))
+	for serviceName, endpoint := range endpoints {
+		wg.Add(1)
+		go func(serviceName string, endpoint string) {
+			defer wg.Done()
+			meta, err := v.metaInfo(endpoint)
+			ch <- nameMetaErr{serviceName, meta, err}
+		}(serviceName, endpoint)
+	}
+	wg.Wait()
+	close(ch)
+
+	metas := map[string]interface{}{}
+	var errs []string
+	for nme := range ch {
+		if nme.err != nil {
+			prefix := ""
+			if nme.name != "" {
+				prefix = "[" + nme.name + "] "
+			}
+			errs = append(errs, fmt.Sprintf("%s%v", prefix, nme.err.Error()))
+		}
+		if nme.meta != nil {
+			metas[nme.name] = nme.meta
+		}
+	}
+
+	if len(errs) > 0 {
+		return nil, errors.Errorf(strings.Join(errs, ", "))
+	}
+	if len(metas) == 1 {
+		for _, meta := range metas {
+			return meta.(map[string]interface{}), nil
+		}
+	}
+	return metas, nil
+}
+
+func (v *vectorizer) metaInfo(endpoint string) (map[string]interface{}, error) {
+	req, err := http.NewRequestWithContext(context.Background(), "GET", endpoint, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "create GET meta request")
+	}
+
+	res, err := v.httpClient.Do(req)
+	if err != nil {
+		return nil, errors.Wrap(err, "send GET meta request")
+	}
+	defer res.Body.Close()
+	if !(res.StatusCode >= http.StatusOK && res.StatusCode < http.StatusMultipleChoices) {
+		return nil, errors.Errorf("unexpected status code '%d' of meta request", res.StatusCode)
+	}
+
+	bodyBytes, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, errors.Wrap(err, "read meta response body")
+	}
+
+	var resBody map[string]interface{}
+	if err := json.Unmarshal(bodyBytes, &resBody); err != nil {
+		return nil, errors.Wrap(err, "unmarshal meta response body")
+	}
+	return resBody, nil
+}

modules/text2vec-transformers/clients/meta_test.go

@@ -0,0 +1,350 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package clients
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetMeta(t *testing.T) {
+	t.Run("when common server is providing meta", func(t *testing.T) {
+		server := httptest.NewServer(&testMetaHandler{t: t})
+		defer server.Close()
+		v := New(server.URL, server.URL, 0, nullLogger())
+		meta, err := v.MetaInfo()
+
+		assert.Nil(t, err)
+		assert.NotNil(t, meta)
+
+		model := extractChildMap(t, meta, "model")
+		assert.NotNil(t, model["_name_or_path"])
+		assert.NotNil(t, model["architectures"])
+		assert.Contains(t, model["architectures"], "DistilBertModel")
+		ID2Label := extractChildMap(t, model, "id2label")
+		assert.NotNil(t, ID2Label["0"])
+		assert.NotNil(t, ID2Label["1"])
+	})
+
+	t.Run("when passage and query servers are providing meta", func(t *testing.T) {
+		serverPassage := httptest.NewServer(&testMetaHandler{t: t, modelType: "passage"})
+		serverQuery := httptest.NewServer(&testMetaHandler{t: t, modelType: "query"})
+		defer serverPassage.Close()
+		defer serverQuery.Close()
+		v := New(serverPassage.URL, serverQuery.URL, 0, nullLogger())
+		meta, err := v.MetaInfo()
+
+		assert.Nil(t, err)
+		assert.NotNil(t, meta)
+
+		passage := extractChildMap(t, meta, "passage")
+		passageModel := extractChildMap(t, passage, "model")
+		assert.NotNil(t, passageModel["_name_or_path"])
+		assert.NotNil(t, passageModel["architectures"])
+		assert.Contains(t, passageModel["architectures"], "DPRContextEncoder")
+		passageID2Label := extractChildMap(t, passageModel, "id2label")
+		assert.NotNil(t, passageID2Label["0"])
+		assert.NotNil(t, passageID2Label["1"])
+
+		query := extractChildMap(t, meta, "query")
+		queryModel := extractChildMap(t, query, "model")
+		assert.NotNil(t, queryModel["_name_or_path"])
+		assert.NotNil(t, queryModel["architectures"])
+		assert.Contains(t, queryModel["architectures"], "DPRQuestionEncoder")
+		queryID2Label := extractChildMap(t, queryModel, "id2label")
+		assert.NotNil(t, queryID2Label["0"])
+		assert.NotNil(t, queryID2Label["1"])
+	})
+
+	t.Run("when passage and query servers are unavailable", func(t *testing.T) {
+		rt := time.Now().Add(time.Hour)
+		serverPassage := httptest.NewServer(&testMetaHandler{t: t, modelType: "passage", readyTime: rt})
+		serverQuery := httptest.NewServer(&testMetaHandler{t: t, modelType: "query", readyTime: rt})
+		defer serverPassage.Close()
+		defer serverQuery.Close()
+		v := New(serverPassage.URL, serverQuery.URL, 0, nullLogger())
+		meta, err := v.MetaInfo()
+
+		assert.NotNil(t, err)
+		assert.Contains(t, err.Error(), "[passage] unexpected status code '503' of meta request")
+		assert.Contains(t, err.Error(), "[query] unexpected status code '503' of meta request")
+		assert.Nil(t, meta)
+	})
+}
+
+type testMetaHandler struct {
+	t *testing.T
+	// the test handler will report as not ready before the time has passed
+	readyTime time.Time
+	modelType string
+}
+
+func (h *testMetaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	assert.Equal(h.t, "/meta", r.URL.String())
+	assert.Equal(h.t, http.MethodGet, r.Method)
+
+	if time.Since(h.readyTime) < 0 {
+		w.WriteHeader(http.StatusServiceUnavailable)
+		return
+	}
+
+	w.Write([]byte(h.metaInfo()))
+}
+
+func (h *testMetaHandler) metaInfo() string {
+	switch h.modelType {
+	case "passage":
+		return `{
+              "model": {
+                "return_dict": true,
+                "output_hidden_states": false,
+                "output_attentions": false,
+                "torchscript": false,
+                "torch_dtype": "float32",
+                "use_bfloat16": false,
+                "pruned_heads": {},
+                "tie_word_embeddings": true,
+                "is_encoder_decoder": false,
+                "is_decoder": false,
+                "cross_attention_hidden_size": null,
+                "add_cross_attention": false,
+                "tie_encoder_decoder": false,
+                "max_length": 20,
+                "min_length": 0,
+                "do_sample": false,
+                "early_stopping": false,
+                "num_beams": 1,
+                "num_beam_groups": 1,
+                "diversity_penalty": 0,
+                "temperature": 1,
+                "top_k": 50,
+                "top_p": 1,
+                "repetition_penalty": 1,
+                "length_penalty": 1,
+                "no_repeat_ngram_size": 0,
+                "encoder_no_repeat_ngram_size": 0,
+                "bad_words_ids": null,
+                "num_return_sequences": 1,
+                "chunk_size_feed_forward": 0,
+                "output_scores": false,
+                "return_dict_in_generate": false,
+                "forced_bos_token_id": null,
+                "forced_eos_token_id": null,
+                "remove_invalid_values": false,
+                "architectures": [
+                  "DPRContextEncoder"
+                ],
+                "finetuning_task": null,
+                "id2label": {
+                  "0": "LABEL_0",
+                  "1": "LABEL_1"
+                },
+                "label2id": {
+                  "LABEL_0": 0,
+                  "LABEL_1": 1
+                },
+                "tokenizer_class": null,
+                "prefix": null,
+                "bos_token_id": null,
+                "pad_token_id": 0,
+                "eos_token_id": null,
+                "sep_token_id": null,
+                "decoder_start_token_id": null,
+                "task_specific_params": null,
+                "problem_type": null,
+                "_name_or_path": "./models/model",
+                "transformers_version": "4.16.2",
+                "gradient_checkpointing": false,
+                "model_type": "dpr",
+                "vocab_size": 30522,
+                "hidden_size": 768,
+                "num_hidden_layers": 12,
+                "num_attention_heads": 12,
+                "hidden_act": "gelu",
+                "intermediate_size": 3072,
+                "hidden_dropout_prob": 0.1,
+                "attention_probs_dropout_prob": 0.1,
+                "max_position_embeddings": 512,
+                "type_vocab_size": 2,
+                "initializer_range": 0.02,
+                "layer_norm_eps": 1e-12,
+                "projection_dim": 0,
+                "position_embedding_type": "absolute"
+              }
+            }`
+	case "query":
+		return `{
+              "model": {
+                "return_dict": true,
+                "output_hidden_states": false,
+                "output_attentions": false,
+                "torchscript": false,
+                "torch_dtype": "float32",
+                "use_bfloat16": false,
+                "pruned_heads": {},
+                "tie_word_embeddings": true,
+                "is_encoder_decoder": false,
+                "is_decoder": false,
+                "cross_attention_hidden_size": null,
+                "add_cross_attention": false,
+                "tie_encoder_decoder": false,
+                "max_length": 20,
+                "min_length": 0,
+                "do_sample": false,
+                "early_stopping": false,
+                "num_beams": 1,
+                "num_beam_groups": 1,
+                "diversity_penalty": 0,
+                "temperature": 1,
+                "top_k": 50,
+                "top_p": 1,
+                "repetition_penalty": 1,
+                "length_penalty": 1,
+                "no_repeat_ngram_size": 0,
+                "encoder_no_repeat_ngram_size": 0,
+                "bad_words_ids": null,
+                "num_return_sequences": 1,
+                "chunk_size_feed_forward": 0,
+                "output_scores": false,
+                "return_dict_in_generate": false,
+                "forced_bos_token_id": null,
+                "forced_eos_token_id": null,
+                "remove_invalid_values": false,
+                "architectures": [
+                  "DPRQuestionEncoder"
+                ],
+                "finetuning_task": null,
+                "id2label": {
+                  "0": "LABEL_0",
+                  "1": "LABEL_1"
+                },
+                "label2id": {
+                  "LABEL_0": 0,
+                  "LABEL_1": 1
+                },
+                "tokenizer_class": null,
+                "prefix": null,
+                "bos_token_id": null,
+                "pad_token_id": 0,
+                "eos_token_id": null,
+                "sep_token_id": null,
+                "decoder_start_token_id": null,
+                "task_specific_params": null,
+                "problem_type": null,
+                "_name_or_path": "./models/model",
+                "transformers_version": "4.16.2",
+                "gradient_checkpointing": false,
+                "model_type": "dpr",
+                "vocab_size": 30522,
+                "hidden_size": 768,
+                "num_hidden_layers": 12,
+                "num_attention_heads": 12,
+                "hidden_act": "gelu",
+                "intermediate_size": 3072,
+                "hidden_dropout_prob": 0.1,
+                "attention_probs_dropout_prob": 0.1,
+                "max_position_embeddings": 512,
+                "type_vocab_size": 2,
+                "initializer_range": 0.02,
+                "layer_norm_eps": 1e-12,
+                "projection_dim": 0,
+                "position_embedding_type": "absolute"
+              }
+            }`
+	default:
+		return `{
+              "model": {
+                "_name_or_path": "distilbert-base-uncased",
+                "activation": "gelu",
+                "add_cross_attention": false,
+                "architectures": [
+                  "DistilBertModel"
+                ],
+                "attention_dropout": 0.1,
+                "bad_words_ids": null,
+                "bos_token_id": null,
+                "chunk_size_feed_forward": 0,
+                "decoder_start_token_id": null,
+                "dim": 768,
+                "diversity_penalty": 0,
+                "do_sample": false,
+                "dropout": 0.1,
+                "early_stopping": false,
+                "encoder_no_repeat_ngram_size": 0,
+                "eos_token_id": null,
+                "finetuning_task": null,
+                "hidden_dim": 3072,
+                "id2label": {
+                  "0": "LABEL_0",
+                  "1": "LABEL_1"
+                },
+                "initializer_range": 0.02,
+                "is_decoder": false,
+                "is_encoder_decoder": false,
+                "label2id": {
+                  "LABEL_0": 0,
+                  "LABEL_1": 1
+                },
+                "length_penalty": 1,
+                "max_length": 20,
+                "max_position_embeddings": 512,
+                "min_length": 0,
+                "model_type": "distilbert",
+                "n_heads": 12,
+                "n_layers": 6,
+                "no_repeat_ngram_size": 0,
+                "num_beam_groups": 1,
+                "num_beams": 1,
+                "num_return_sequences": 1,
+                "output_attentions": false,
+                "output_hidden_states": false,
+                "output_scores": false,
+                "pad_token_id": 0,
+                "prefix": null,
+                "pruned_heads": {},
+                "qa_dropout": 0.1,
+                "repetition_penalty": 1,
+                "return_dict": true,
+                "return_dict_in_generate": false,
+                "sep_token_id": null,
+                "seq_classif_dropout": 0.2,
+                "sinusoidal_pos_embds": false,
+                "task_specific_params": null,
+                "temperature": 1,
+                "tie_encoder_decoder": false,
+                "tie_weights_": true,
+                "tie_word_embeddings": true,
+                "tokenizer_class": null,
+                "top_k": 50,
+                "top_p": 1,
+                "torchscript": false,
+                "transformers_version": "4.3.2",
+                "use_bfloat16": false,
+                "vocab_size": 30522,
+                "xla_device": null
+              }
+            }`
+	}
+}
+
+func extractChildMap(t *testing.T, parent map[string]interface{}, name string) map[string]interface{} {
+	assert.NotNil(t, parent[name])
+	child, ok := parent[name].(map[string]interface{})
+	assert.True(t, ok)
+	assert.NotNil(t, child)
+
+	return child
+}

modules/text2vec-transformers/clients/startup.go

@@ -0,0 +1,109 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package clients
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+func (v *vectorizer) WaitForStartup(initCtx context.Context,
+	interval time.Duration,
+) error {
+	endpoints := map[string]string{}
+	if v.originPassage != v.originQuery {
+		endpoints["passage"] = v.urlPassage("/.well-known/ready")
+		endpoints["query"] = v.urlQuery("/.well-known/ready")
+	} else {
+		endpoints[""] = v.urlPassage("/.well-known/ready")
+	}
+
+	ch := make(chan error, len(endpoints))
+	var wg sync.WaitGroup
+	for serviceName, endpoint := range endpoints {
+		wg.Add(1)
+		go func(serviceName string, endpoint string) {
+			defer wg.Done()
+			if err := v.waitFor(initCtx, interval, endpoint, serviceName); err != nil {
+				ch <- err
+			}
+		}(serviceName, endpoint)
+	}
+	wg.Wait()
+	close(ch)
+
+	if len(ch) > 0 {
+		var errs []string
+		for err := range ch {
+			errs = append(errs, err.Error())
+		}
+		return errors.Errorf(strings.Join(errs, ", "))
+	}
+	return nil
+}
+
+func (v *vectorizer) waitFor(initCtx context.Context, interval time.Duration, endpoint string, serviceName string) error {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	expired := initCtx.Done()
+	var lastErr error
+	prefix := ""
+	if serviceName != "" {
+		prefix = "[" + serviceName + "] "
+	}
+
+	for {
+		select {
+		case <-ticker.C:
+			lastErr = v.checkReady(initCtx, endpoint, serviceName)
+			if lastErr == nil {
+				return nil
+			}
+			v.logger.
+				WithField("action", "transformer_remote_wait_for_startup").
+				WithError(lastErr).Warnf("%stransformer remote inference service not ready", prefix)
+		case <-expired:
+			return errors.Wrapf(lastErr, "%sinit context expired before remote was ready", prefix)
+		}
+	}
+}
+
+func (v *vectorizer) checkReady(initCtx context.Context, endpoint string, serviceName string) error {
+	// spawn a new context (derived on the overall context) which is used to
+	// consider an individual request timed out
+	// due to parent timeout being superior over request's one, request can be cancelled by parent timeout
+	// resulting in "send check ready request" even if service is responding with non 2xx http code
+	requestCtx, cancel := context.WithTimeout(initCtx, 500*time.Millisecond)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(requestCtx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return errors.Wrap(err, "create check ready request")
+	}
+
+	res, err := v.httpClient.Do(req)
+	if err != nil {
+		return errors.Wrap(err, "send check ready request")
+	}
+
+	defer res.Body.Close()
+	if res.StatusCode > 299 {
+		return errors.Errorf("not ready: status %d", res.StatusCode)
+	}
+
+	return nil
+}

modules/text2vec-transformers/clients/startup_test.go

@@ -0,0 +1,197 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package clients
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWaitForStartup(t *testing.T) {
+	t.Run("when common server is immediately ready", func(t *testing.T) {
+		server := httptest.NewServer(&testReadyHandler{t: t})
+		defer server.Close()
+		v := New(server.URL, server.URL, 0, nullLogger())
+		err := v.WaitForStartup(context.Background(), 150*time.Millisecond)
+
+		assert.Nil(t, err)
+	})
+
+	t.Run("when passage and query servers are immediately ready", func(t *testing.T) {
+		serverPassage := httptest.NewServer(&testReadyHandler{t: t})
+		serverQuery := httptest.NewServer(&testReadyHandler{t: t})
+		defer serverPassage.Close()
+		defer serverQuery.Close()
+		v := New(serverPassage.URL, serverQuery.URL, 0, nullLogger())
+		err := v.WaitForStartup(context.Background(), 150*time.Millisecond)
+
+		assert.Nil(t, err)
+	})
+
+	t.Run("when common server is down", func(t *testing.T) {
+		url := "http://nothing-running-at-this-url"
+		v := New(url, url, 0, nullLogger())
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+		err := v.WaitForStartup(ctx, 50*time.Millisecond)
+
+		require.NotNil(t, err, nullLogger())
+		assert.Contains(t, err.Error(), "init context expired before remote was ready: send check ready request")
+		assertContainsEither(t, err.Error(), "dial tcp", "context deadline exceeded")
+		assert.NotContains(t, err.Error(), "[passage]")
+		assert.NotContains(t, err.Error(), "[query]")
+	})
+
+	t.Run("when passage and query servers are down", func(t *testing.T) {
+		urlPassage := "http://nothing-running-at-this-url"
+		urlQuery := "http://nothing-running-at-this-url-either"
+		v := New(urlPassage, urlQuery, 0, nullLogger())
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+		err := v.WaitForStartup(ctx, 50*time.Millisecond)
+
+		require.NotNil(t, err, nullLogger())
+		assert.Contains(t, err.Error(), "[passage] init context expired before remote was ready: send check ready request")
+		assert.Contains(t, err.Error(), "[query] init context expired before remote was ready: send check ready request")
+		assertContainsEither(t, err.Error(), "dial tcp", "context deadline exceeded")
+	})
+
+	t.Run("when common server is alive, but not ready", func(t *testing.T) {
+		server := httptest.NewServer(&testReadyHandler{
+			t:         t,
+			readyTime: time.Now().Add(time.Hour),
+		})
+		defer server.Close()
+		v := New(server.URL, server.URL, 0, nullLogger())
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+		err := v.WaitForStartup(ctx, 50*time.Millisecond)
+
+		require.NotNil(t, err)
+		assert.Contains(t, err.Error(), "init context expired before remote was ready")
+		assertContainsEither(t, err.Error(), "not ready: status 503", "context deadline exceeded")
+		assert.NotContains(t, err.Error(), "[passage]")
+		assert.NotContains(t, err.Error(), "[query]")
+	})
+
+	t.Run("when passage and query servers are alive, but not ready", func(t *testing.T) {
+		rt := time.Now().Add(time.Hour)
+		serverPassage := httptest.NewServer(&testReadyHandler{
+			t:         t,
+			readyTime: rt,
+		})
+		serverQuery := httptest.NewServer(&testReadyHandler{
+			t:         t,
+			readyTime: rt,
+		})
+		defer serverPassage.Close()
+		defer serverQuery.Close()
+		v := New(serverPassage.URL, serverQuery.URL, 0, nullLogger())
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+		err := v.WaitForStartup(ctx, 50*time.Millisecond)
+
+		require.NotNil(t, err)
+		assert.Contains(t, err.Error(), "[passage] init context expired before remote was ready")
+		assert.Contains(t, err.Error(), "[query] init context expired before remote was ready")
+		assertContainsEither(t, err.Error(), "not ready: status 503", "context deadline exceeded")
+	})
+
+	t.Run("when passage and query servers are alive, but query one is not ready", func(t *testing.T) {
+		serverPassage := httptest.NewServer(&testReadyHandler{t: t})
+		serverQuery := httptest.NewServer(&testReadyHandler{
+			t:         t,
+			readyTime: time.Now().Add(1 * time.Minute),
+		})
+		defer serverPassage.Close()
+		defer serverQuery.Close()
+		v := New(serverPassage.URL, serverQuery.URL, 0, nullLogger())
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+		err := v.WaitForStartup(ctx, 50*time.Millisecond)
+
+		require.NotNil(t, err)
+		assert.Contains(t, err.Error(), "[query] init context expired before remote was ready")
+		assertContainsEither(t, err.Error(), "not ready: status 503", "context deadline exceeded")
+		assert.NotContains(t, err.Error(), "[passage]")
+	})
+
+	t.Run("when common server is initially not ready, but then becomes ready", func(t *testing.T) {
+		server := httptest.NewServer(&testReadyHandler{
+			t:         t,
+			readyTime: time.Now().Add(100 * time.Millisecond),
+		})
+		v := New(server.URL, server.URL, 0, nullLogger())
+		defer server.Close()
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+		err := v.WaitForStartup(ctx, 50*time.Millisecond)
+
+		require.Nil(t, err)
+	})
+
+	t.Run("when passage and query servers are initially not ready, but then become ready", func(t *testing.T) {
+		serverPassage := httptest.NewServer(&testReadyHandler{
+			t:         t,
+			readyTime: time.Now().Add(100 * time.Millisecond),
+		})
+		serverQuery := httptest.NewServer(&testReadyHandler{
+			t:         t,
+			readyTime: time.Now().Add(150 * time.Millisecond),
+		})
+		defer serverPassage.Close()
+		defer serverQuery.Close()
+		v := New(serverPassage.URL, serverQuery.URL, 0, nullLogger())
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+		err := v.WaitForStartup(ctx, 50*time.Millisecond)
+
+		require.Nil(t, err)
+	})
+}
+
+type testReadyHandler struct {
+	t *testing.T
+	// the test handler will report as not ready before the time has passed
+	readyTime time.Time
+}
+
+func (f *testReadyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	assert.Equal(f.t, "/.well-known/ready", r.URL.String())
+	assert.Equal(f.t, http.MethodGet, r.Method)
+
+	if time.Since(f.readyTime) < 0 {
+		w.WriteHeader(http.StatusServiceUnavailable)
+	} else {
+		w.WriteHeader(http.StatusNoContent)
+	}
+}
+
+func nullLogger() logrus.FieldLogger {
+	l, _ := test.NewNullLogger()
+	return l
+}
+
+func assertContainsEither(t *testing.T, str string, contains ...string) {
+	reg := regexp.MustCompile(strings.Join(contains, "|"))
+	assert.Regexp(t, reg, str)
+}

modules/text2vec-transformers/clients/transformers.go

@@ -0,0 +1,123 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package clients
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/modules/text2vec-transformers/ent"
+)
+
+type vectorizer struct {
+	originPassage string
+	originQuery   string
+	httpClient    *http.Client
+	logger        logrus.FieldLogger
+}
+
+func New(originPassage, originQuery string, timeout time.Duration, logger logrus.FieldLogger) *vectorizer {
+	return &vectorizer{
+		originPassage: originPassage,
+		originQuery:   originQuery,
+		httpClient: &http.Client{
+			Timeout: timeout,
+		},
+		logger: logger,
+	}
+}
+
+func (v *vectorizer) VectorizeObject(ctx context.Context, input string,
+	config ent.VectorizationConfig,
+) (*ent.VectorizationResult, error) {
+	return v.vectorize(ctx, input, config, v.urlPassage)
+}
+
+func (v *vectorizer) VectorizeQuery(ctx context.Context, input string,
+	config ent.VectorizationConfig,
+) (*ent.VectorizationResult, error) {
+	return v.vectorize(ctx, input, config, v.urlQuery)
+}
+
+func (v *vectorizer) vectorize(ctx context.Context, input string,
+	config ent.VectorizationConfig, url func(string) string,
+) (*ent.VectorizationResult, error) {
+	body, err := json.Marshal(vecRequest{
+		Text: input,
+		Config: vecRequestConfig{
+			PoolingStrategy: config.PoolingStrategy,
+		},
+	})
+	if err != nil {
+		return nil, errors.Wrapf(err, "marshal body")
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", url("/vectors"),
+		bytes.NewReader(body))
+	if err != nil {
+		return nil, errors.Wrap(err, "create POST request")
+	}
+
+	res, err := v.httpClient.Do(req)
+	if err != nil {
+		return nil, errors.Wrap(err, "send POST request")
+	}
+	defer res.Body.Close()
+
+	bodyBytes, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, errors.Wrap(err, "read response body")
+	}
+
+	var resBody vecRequest
+	if err := json.Unmarshal(bodyBytes, &resBody); err != nil {
+		return nil, errors.Wrap(err, "unmarshal response body")
+	}
+
+	if res.StatusCode > 399 {
+		return nil, errors.Errorf("fail with status %d: %s", res.StatusCode,
+			resBody.Error)
+	}
+
+	return &ent.VectorizationResult{
+		Text:       resBody.Text,
+		Dimensions: resBody.Dims,
+		Vector:     resBody.Vector,
+	}, nil
+}
+
+func (v *vectorizer) urlPassage(path string) string {
+	return fmt.Sprintf("%s%s", v.originPassage, path)
+}
+
+func (v *vectorizer) urlQuery(path string) string {
+	return fmt.Sprintf("%s%s", v.originQuery, path)
+}
+
+type vecRequest struct {
+	Text   string           `json:"text"`
+	Dims   int              `json:"dims"`
+	Vector []float32        `json:"vector"`
+	Error  string           `json:"error"`
+	Config vecRequestConfig `json:"config"`
+}
+
+type vecRequestConfig struct {
+	PoolingStrategy string `json:"pooling_strategy"`
+}

modules/text2vec-transformers/clients/transformers_test.go

@@ -0,0 +1,114 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package clients
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/modules/text2vec-transformers/ent"
+)
+
+func TestClient(t *testing.T) {
+	t.Run("when all is fine", func(t *testing.T) {
+		server := httptest.NewServer(&fakeHandler{t: t})
+		defer server.Close()
+		c := New(server.URL, server.URL, 0, nullLogger())
+		expected := &ent.VectorizationResult{
+			Text:       "This is my text",
+			Vector:     []float32{0.1, 0.2, 0.3},
+			Dimensions: 3,
+		}
+		res, err := c.VectorizeObject(context.Background(), "This is my text",
+			ent.VectorizationConfig{
+				PoolingStrategy: "masked_mean",
+			})
+
+		assert.Nil(t, err)
+		assert.Equal(t, expected, res)
+	})
+
+	t.Run("when the context is expired", func(t *testing.T) {
+		server := httptest.NewServer(&fakeHandler{t: t})
+		defer server.Close()
+		c := New(server.URL, server.URL, 0, nullLogger())
+		ctx, cancel := context.WithDeadline(context.Background(), time.Now())
+		defer cancel()
+
+		_, err := c.VectorizeObject(ctx, "This is my text", ent.VectorizationConfig{})
+
+		require.NotNil(t, err)
+		assert.Contains(t, err.Error(), "context deadline exceeded")
+	})
+
+	t.Run("when the server returns an error", func(t *testing.T) {
+		server := httptest.NewServer(&fakeHandler{
+			t:           t,
+			serverError: errors.Errorf("nope, not gonna happen"),
+		})
+		defer server.Close()
+		c := New(server.URL, server.URL, 0, nullLogger())
+		_, err := c.VectorizeObject(context.Background(), "This is my text",
+			ent.VectorizationConfig{})
+
+		require.NotNil(t, err)
+		assert.Contains(t, err.Error(), "nope, not gonna happen")
+	})
+}
+
+type fakeHandler struct {
+	t           *testing.T
+	serverError error
+}
+
+func (f *fakeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	assert.Equal(f.t, "/vectors", r.URL.String())
+	assert.Equal(f.t, http.MethodPost, r.Method)
+
+	if f.serverError != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte(fmt.Sprintf(`{"error":"%s"}`, f.serverError.Error())))
+		return
+	}
+
+	bodyBytes, err := io.ReadAll(r.Body)
+	require.Nil(f.t, err)
+	defer r.Body.Close()
+
+	var b map[string]interface{}
+	require.Nil(f.t, json.Unmarshal(bodyBytes, &b))
+
+	textInput := b["text"].(string)
+	assert.Greater(f.t, len(textInput), 0)
+
+	pooling := b["config"].(map[string]interface{})["pooling_strategy"].(string)
+	assert.Equal(f.t, "masked_mean", pooling)
+
+	out := map[string]interface{}{
+		"text":   textInput,
+		"dims":   3,
+		"vector": []float32{0.1, 0.2, 0.3},
+	}
+	outBytes, err := json.Marshal(out)
+	require.Nil(f.t, err)
+
+	w.Write(outBytes)
+}

modules/text2vec-transformers/config.go

@@ -0,0 +1,153 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package modtransformers
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/modulecapabilities"
+	"github.com/weaviate/weaviate/entities/moduletools"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/modules/text2vec-transformers/vectorizer"
+)
+
+func (m *TransformersModule) ClassConfigDefaults() map[string]interface{} {
+	return map[string]interface{}{
+		"vectorizeClassName": vectorizer.DefaultVectorizeClassName,
+		"poolingStrategy":    vectorizer.DefaultPoolingStrategy,
+	}
+}
+
+func (m *TransformersModule) PropertyConfigDefaults(
+	dt *schema.DataType,
+) map[string]interface{} {
+	return map[string]interface{}{
+		"skip":                  !vectorizer.DefaultPropertyIndexed,
+		"vectorizePropertyName": vectorizer.DefaultVectorizePropertyName,
+	}
+}
+
+func (m *TransformersModule) ValidateClass(ctx context.Context,
+	class *models.Class, cfg moduletools.ClassConfig,
+) error {
+	settings := vectorizer.NewClassSettings(cfg)
+	return NewConfigValidator(m.logger).Do(ctx, class, cfg, settings)
+}
+
+var _ = modulecapabilities.ClassConfigurator(New())
+
+type ConfigValidator struct {
+	logger logrus.FieldLogger
+}
+
+type ClassSettings interface {
+	VectorizeClassName() bool
+	VectorizePropertyName(propName string) bool
+	PropertyIndexed(propName string) bool
+}
+
+func NewConfigValidator(logger logrus.FieldLogger) *ConfigValidator {
+	return &ConfigValidator{logger: logger}
+}
+
+func (cv *ConfigValidator) Do(ctx context.Context, class *models.Class,
+	cfg moduletools.ClassConfig, settings ClassSettings,
+) error {
+	// In text2vec-transformers (as opposed to e.g. text2vec-contextionary) the
+	// assumption is that the models will be able to deal with any words, even
+	// previously unseen ones. Therefore we do not need to validate individual
+	// properties, but only the overall "index state"
+
+	if err := cv.validateIndexState(ctx, class, settings); err != nil {
+		return errors.Errorf("invalid combination of properties")
+	}
+
+	cv.checkForPossibilityOfDuplicateVectors(ctx, class, settings)
+
+	return nil
+}
+
+func (cv *ConfigValidator) validateIndexState(ctx context.Context,
+	class *models.Class, settings ClassSettings,
+) error {
+	if settings.VectorizeClassName() {
+		// if the user chooses to vectorize the classname, vector-building will
+		// always be possible, no need to investigate further
+
+		return nil
+	}
+
+	// search if there is at least one indexed, string/text prop. If found pass
+	// validation
+	for _, prop := range class.Properties {
+		if len(prop.DataType) < 1 {
+			return errors.Errorf("property %s must have at least one datatype: "+
+				"got %v", prop.Name, prop.DataType)
+		}
+
+		if prop.DataType[0] != string(schema.DataTypeText) {
+			// we can only vectorize text-like props
+			continue
+		}
+
+		if settings.PropertyIndexed(prop.Name) {
+			// found at least one, this is a valid schema
+			return nil
+		}
+	}
+
+	return fmt.Errorf("invalid properties: didn't find a single property which is " +
+		"of type string or text and is not excluded from indexing. In addition the " +
+		"class name is excluded from vectorization as well, meaning that it cannot be " +
+		"used to determine the vector position. To fix this, set 'vectorizeClassName' " +
+		"to true if the class name is contextionary-valid. Alternatively add at least " +
+		"contextionary-valid text/string property which is not excluded from " +
+		"indexing.")
+}
+
+func (cv *ConfigValidator) checkForPossibilityOfDuplicateVectors(
+	ctx context.Context, class *models.Class, settings ClassSettings,
+) {
+	if !settings.VectorizeClassName() {
+		// if the user choses not to vectorize the class name, this means they must
+		// have chosen something else to vectorize, otherwise the validation would
+		// have error'd before we ever got here. We can skip further checking.
+
+		return
+	}
+
+	// search if there is at least one indexed, string/text prop. If found exit
+	for _, prop := range class.Properties {
+		// length check skipped, because validation has already passed
+		if prop.DataType[0] != string(schema.DataTypeText) {
+			// we can only vectorize text-like props
+			continue
+		}
+
+		if settings.PropertyIndexed(prop.Name) {
+			// found at least one
+			return
+		}
+	}
+
+	cv.logger.WithField("module", "text2vec-transformers").
+		WithField("class", class.Class).
+		Warnf("text2vec-contextionary: Class %q does not have any properties "+
+			"indexed (or only non text-properties indexed) and the vector position is "+
+			"only determined by the class name. Each object will end up with the same "+
+			"vector which leads to a severe performance penalty on imports. Consider "+
+			"setting vectorIndexConfig.skip=true for this property", class.Class)
+}

modules/text2vec-transformers/config_test.go

@@ -0,0 +1,188 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package modtransformers
+
+import (
+	"context"
+	"testing"
+
+	"github.com/sirupsen/logrus"
+	ltest "github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func TestConfigDefaults(t *testing.T) {
+	t.Run("for properties", func(t *testing.T) {
+		def := New().ClassConfigDefaults()
+
+		assert.Equal(t, true, def["vectorizeClassName"])
+		assert.Equal(t, "masked_mean", def["poolingStrategy"])
+	})
+
+	t.Run("for the class", func(t *testing.T) {
+		dt := schema.DataTypeText
+		def := New().PropertyConfigDefaults(&dt)
+		assert.Equal(t, false, def["vectorizePropertyName"])
+		assert.Equal(t, false, def["skip"])
+	})
+}
+
+func TestConfigValidator(t *testing.T) {
+	t.Run("all usable props no-indexed", func(t *testing.T) {
+		t.Run("all schema vectorization turned off", func(t *testing.T) {
+			class := &models.Class{
+				Vectorizer: "text2vec-contextionary",
+				Class:      "ValidName",
+				Properties: []*models.Property{
+					{
+						DataType: []string{"text"},
+						Name:     "description",
+					},
+					{
+						DataType:     schema.DataTypeText.PropString(),
+						Tokenization: models.PropertyTokenizationWhitespace,
+						Name:         "name",
+					},
+					{
+						DataType: []string{"int"},
+						Name:     "amount",
+					},
+				},
+			}
+
+			logger, _ := ltest.NewNullLogger()
+			v := NewConfigValidator(logger)
+			err := v.Do(context.Background(), class, nil, &fakeIndexChecker{
+				vectorizePropertyName: false,
+				vectorizeClassName:    false,
+				propertyIndexed:       false,
+			})
+			assert.NotNil(t, err)
+		})
+	})
+}
+
+func TestConfigValidator_RiskOfDuplicateVectors(t *testing.T) {
+	type test struct {
+		name          string
+		in            *models.Class
+		expectWarning bool
+		indexChecker  *fakeIndexChecker
+	}
+
+	tests := []test{
+		{
+			name: "usable properties",
+			in: &models.Class{
+				Class: "ValidName",
+				Properties: []*models.Property{
+					{
+						DataType: []string{string(schema.DataTypeText)},
+						Name:     "textProp",
+					},
+				},
+			},
+			expectWarning: false,
+			indexChecker: &fakeIndexChecker{
+				vectorizePropertyName: false,
+				vectorizeClassName:    true,
+				propertyIndexed:       true,
+			},
+		},
+		{
+			name: "no properties",
+			in: &models.Class{
+				Class: "ValidName",
+			},
+			expectWarning: true,
+			indexChecker: &fakeIndexChecker{
+				vectorizePropertyName: false,
+				vectorizeClassName:    true,
+				propertyIndexed:       false,
+			},
+		},
+		{
+			name: "usable properties, but they are no-indexed",
+			in: &models.Class{
+				Class: "ValidName",
+				Properties: []*models.Property{
+					{
+						DataType: []string{string(schema.DataTypeText)},
+						Name:     "textProp",
+					},
+				},
+			},
+			expectWarning: true,
+			indexChecker: &fakeIndexChecker{
+				vectorizePropertyName: false,
+				vectorizeClassName:    true,
+				propertyIndexed:       false,
+			},
+		},
+		{
+			name: "only unusable properties",
+			in: &models.Class{
+				Class: "ValidName",
+				Properties: []*models.Property{
+					{
+						DataType: []string{string(schema.DataTypeInt)},
+						Name:     "intProp",
+					},
+				},
+			},
+			expectWarning: true,
+			indexChecker: &fakeIndexChecker{
+				vectorizePropertyName: false,
+				vectorizeClassName:    true,
+				propertyIndexed:       false,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			logger, hook := ltest.NewNullLogger()
+			v := NewConfigValidator(logger)
+			err := v.Do(context.Background(), test.in, nil, test.indexChecker)
+			require.Nil(t, err)
+
+			entry := hook.LastEntry()
+			if test.expectWarning {
+				require.NotNil(t, entry)
+				assert.Equal(t, logrus.WarnLevel, entry.Level)
+			} else {
+				assert.Nil(t, entry)
+			}
+		})
+	}
+}
+
+type fakeIndexChecker struct {
+	vectorizeClassName    bool
+	vectorizePropertyName bool
+	propertyIndexed       bool
+}
+
+func (f *fakeIndexChecker) VectorizeClassName() bool {
+	return f.vectorizeClassName
+}
+
+func (f *fakeIndexChecker) VectorizePropertyName(propName string) bool {
+	return f.vectorizePropertyName
+}
+
+func (f *fakeIndexChecker) PropertyIndexed(propName string) bool {
+	return f.propertyIndexed
+}

modules/text2vec-transformers/ent/vectorization_config.go

@@ -0,0 +1,16 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package ent
+
+type VectorizationConfig struct {
+	PoolingStrategy string
+}

modules/text2vec-transformers/ent/vectorization_result.go

@@ -0,0 +1,18 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package ent
+
+type VectorizationResult struct {
+	Text       string
+	Dimensions int
+	Vector     []float32
+}

modules/text2vec-transformers/module.go

@@ -0,0 +1,169 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package modtransformers
+
+import (
+	"context"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/modulecapabilities"
+	"github.com/weaviate/weaviate/entities/moduletools"
+	"github.com/weaviate/weaviate/modules/text2vec-transformers/clients"
+	"github.com/weaviate/weaviate/modules/text2vec-transformers/vectorizer"
+	"github.com/weaviate/weaviate/usecases/modulecomponents/additional"
+)
+
+func New() *TransformersModule {
+	return &TransformersModule{}
+}
+
+type TransformersModule struct {
+	vectorizer                   textVectorizer
+	metaProvider                 metaProvider
+	graphqlProvider              modulecapabilities.GraphQLArguments
+	searcher                     modulecapabilities.Searcher
+	nearTextTransformer          modulecapabilities.TextTransform
+	logger                       logrus.FieldLogger
+	additionalPropertiesProvider modulecapabilities.AdditionalProperties
+}
+
+type textVectorizer interface {
+	Object(ctx context.Context, obj *models.Object, objDiff *moduletools.ObjectDiff,
+		cfg moduletools.ClassConfig) error
+	Texts(ctx context.Context, input []string,
+		cfg moduletools.ClassConfig) ([]float32, error)
+}
+
+type metaProvider interface {
+	MetaInfo() (map[string]interface{}, error)
+}
+
+func (m *TransformersModule) Name() string {
+	return "text2vec-transformers"
+}
+
+func (m *TransformersModule) Type() modulecapabilities.ModuleType {
+	return modulecapabilities.Text2Vec
+}
+
+func (m *TransformersModule) Init(ctx context.Context,
+	params moduletools.ModuleInitParams,
+) error {
+	m.logger = params.GetLogger()
+
+	if err := m.initVectorizer(ctx, params.GetConfig().ModuleHttpClientTimeout, m.logger); err != nil {
+		return errors.Wrap(err, "init vectorizer")
+	}
+
+	if err := m.initAdditionalPropertiesProvider(); err != nil {
+		return errors.Wrap(err, "init additional properties provider")
+	}
+
+	return nil
+}
+
+func (m *TransformersModule) InitExtension(modules []modulecapabilities.Module) error {
+	for _, module := range modules {
+		if module.Name() == m.Name() {
+			continue
+		}
+		if arg, ok := module.(modulecapabilities.TextTransformers); ok {
+			if arg != nil && arg.TextTransformers() != nil {
+				m.nearTextTransformer = arg.TextTransformers()["nearText"]
+			}
+		}
+	}
+
+	if err := m.initNearText(); err != nil {
+		return errors.Wrap(err, "init graphql provider")
+	}
+	return nil
+}
+
+func (m *TransformersModule) initVectorizer(ctx context.Context, timeout time.Duration,
+	logger logrus.FieldLogger,
+) error {
+	// TODO: gh-1486 proper config management
+	uriPassage := os.Getenv("TRANSFORMERS_PASSAGE_INFERENCE_API")
+	uriQuery := os.Getenv("TRANSFORMERS_QUERY_INFERENCE_API")
+	uriCommon := os.Getenv("TRANSFORMERS_INFERENCE_API")
+
+	if uriCommon == "" {
+		if uriPassage == "" && uriQuery == "" {
+			return errors.Errorf("required variable TRANSFORMERS_INFERENCE_API or both variables TRANSFORMERS_PASSAGE_INFERENCE_API and TRANSFORMERS_QUERY_INFERENCE_API are not set")
+		}
+		if uriPassage != "" && uriQuery == "" {
+			return errors.Errorf("required variable TRANSFORMERS_QUERY_INFERENCE_API is not set")
+		}
+		if uriPassage == "" && uriQuery != "" {
+			return errors.Errorf("required variable TRANSFORMERS_PASSAGE_INFERENCE_API is not set")
+		}
+	} else {
+		if uriPassage != "" || uriQuery != "" {
+			return errors.Errorf("either variable TRANSFORMERS_INFERENCE_API or both variables TRANSFORMERS_PASSAGE_INFERENCE_API and TRANSFORMERS_QUERY_INFERENCE_API should be set")
+		}
+		uriPassage = uriCommon
+		uriQuery = uriCommon
+	}
+
+	client := clients.New(uriPassage, uriQuery, timeout, logger)
+	if err := client.WaitForStartup(ctx, 1*time.Second); err != nil {
+		return errors.Wrap(err, "init remote vectorizer")
+	}
+
+	m.vectorizer = vectorizer.New(client)
+	m.metaProvider = client
+
+	return nil
+}
+
+func (m *TransformersModule) initAdditionalPropertiesProvider() error {
+	m.additionalPropertiesProvider = additional.NewText2VecProvider()
+	return nil
+}
+
+func (m *TransformersModule) RootHandler() http.Handler {
+	// TODO: remove once this is a capability interface
+	return nil
+}
+
+func (m *TransformersModule) VectorizeObject(ctx context.Context,
+	obj *models.Object, objDiff *moduletools.ObjectDiff, cfg moduletools.ClassConfig,
+) error {
+	return m.vectorizer.Object(ctx, obj, objDiff, cfg)
+}
+
+func (m *TransformersModule) MetaInfo() (map[string]interface{}, error) {
+	return m.metaProvider.MetaInfo()
+}
+
+func (m *TransformersModule) AdditionalProperties() map[string]modulecapabilities.AdditionalProperty {
+	return m.additionalPropertiesProvider.AdditionalProperties()
+}
+
+func (m *TransformersModule) VectorizeInput(ctx context.Context,
+	input string, cfg moduletools.ClassConfig,
+) ([]float32, error) {
+	return m.vectorizer.Texts(ctx, []string{input}, cfg)
+}
+
+// verify we implement the modules.Module interface
+var (
+	_ = modulecapabilities.Module(New())
+	_ = modulecapabilities.Vectorizer(New())
+	_ = modulecapabilities.MetaProvider(New())
+)

modules/text2vec-transformers/nearText.go

@@ -0,0 +1,36 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package modtransformers
+
+import (
+	"github.com/weaviate/weaviate/entities/modulecapabilities"
+	"github.com/weaviate/weaviate/usecases/modulecomponents/nearText"
+)
+
+func (m *TransformersModule) initNearText() error {
+	m.searcher = nearText.NewSearcher(m.vectorizer)
+	m.graphqlProvider = nearText.New(m.nearTextTransformer)
+	return nil
+}
+
+func (m *TransformersModule) Arguments() map[string]modulecapabilities.GraphQLArgument {
+	return m.graphqlProvider.Arguments()
+}
+
+func (m *TransformersModule) VectorSearches() map[string]modulecapabilities.VectorForParams {
+	return m.searcher.VectorSearches()
+}
+
+var (
+	_ = modulecapabilities.GraphQLArguments(New())
+	_ = modulecapabilities.Searcher(New())
+)

modules/text2vec-transformers/vectorizer/class_settings.go

@@ -0,0 +1,106 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package vectorizer
+
+import (
+	"github.com/weaviate/weaviate/entities/moduletools"
+)
+
+const (
+	DefaultPropertyIndexed       = true
+	DefaultVectorizeClassName    = true
+	DefaultVectorizePropertyName = false
+	DefaultPoolingStrategy       = "masked_mean"
+)
+
+type classSettings struct {
+	cfg moduletools.ClassConfig
+}
+
+func NewClassSettings(cfg moduletools.ClassConfig) *classSettings {
+	return &classSettings{cfg: cfg}
+}
+
+func (ic *classSettings) PropertyIndexed(propName string) bool {
+	if ic.cfg == nil {
+		// we would receive a nil-config on cross-class requests, such as Explore{}
+		return DefaultPropertyIndexed
+	}
+
+	vcn, ok := ic.cfg.Property(propName)["skip"]
+	if !ok {
+		return DefaultPropertyIndexed
+	}
+
+	asBool, ok := vcn.(bool)
+	if !ok {
+		return DefaultPropertyIndexed
+	}
+
+	return !asBool
+}
+
+func (ic *classSettings) VectorizePropertyName(propName string) bool {
+	if ic.cfg == nil {
+		// we would receive a nil-config on cross-class requests, such as Explore{}
+		return DefaultVectorizePropertyName
+	}
+	vcn, ok := ic.cfg.Property(propName)["vectorizePropertyName"]
+	if !ok {
+		return DefaultVectorizePropertyName
+	}
+
+	asBool, ok := vcn.(bool)
+	if !ok {
+		return DefaultVectorizePropertyName
+	}
+
+	return asBool
+}
+
+func (ic *classSettings) VectorizeClassName() bool {
+	if ic.cfg == nil {
+		// we would receive a nil-config on cross-class requests, such as Explore{}
+		return DefaultVectorizeClassName
+	}
+
+	vcn, ok := ic.cfg.Class()["vectorizeClassName"]
+	if !ok {
+		return DefaultVectorizeClassName
+	}
+
+	asBool, ok := vcn.(bool)
+	if !ok {
+		return DefaultVectorizeClassName
+	}
+
+	return asBool
+}
+
+func (ic *classSettings) PoolingStrategy() string {
+	if ic.cfg == nil {
+		// we would receive a nil-config on cross-class requests, such as Explore{}
+		return DefaultPoolingStrategy
+	}
+
+	vcn, ok := ic.cfg.Class()["poolingStrategy"]
+	if !ok {
+		return DefaultPoolingStrategy
+	}
+
+	asString, ok := vcn.(string)
+	if !ok {
+		return DefaultPoolingStrategy
+	}
+
+	return asString
+}

modules/text2vec-transformers/vectorizer/class_settings_test.go

@@ -0,0 +1,110 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package vectorizer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/usecases/modules"
+)
+
+func TestClassSettings(t *testing.T) {
+	t.Run("with all defaults", func(t *testing.T) {
+		class := &models.Class{
+			Class: "MyClass",
+			Properties: []*models.Property{{
+				Name: "someProp",
+			}},
+		}
+
+		cfg := modules.NewClassBasedModuleConfig(class, "my-module", "tenant")
+		ic := NewClassSettings(cfg)
+
+		assert.True(t, ic.PropertyIndexed("someProp"))
+		assert.False(t, ic.VectorizePropertyName("someProp"))
+		assert.True(t, ic.VectorizeClassName())
+		assert.Equal(t, ic.PoolingStrategy(), "masked_mean")
+	})
+
+	t.Run("with a nil config", func(t *testing.T) {
+		// this is the case if we were running in a situation such as a
+		// cross-class vectorization of search time, as is the case with Explore
+		// {}, we then expect all default values
+
+		ic := NewClassSettings(nil)
+
+		assert.True(t, ic.PropertyIndexed("someProp"))
+		assert.False(t, ic.VectorizePropertyName("someProp"))
+		assert.True(t, ic.VectorizeClassName())
+		assert.Equal(t, ic.PoolingStrategy(), "masked_mean")
+	})
+
+	t.Run("with all explicit config matching the defaults", func(t *testing.T) {
+		class := &models.Class{
+			Class: "MyClass",
+			ModuleConfig: map[string]interface{}{
+				"my-module": map[string]interface{}{
+					"vectorizeClassName": true,
+					"poolingStrategy":    "masked_mean",
+				},
+			},
+			Properties: []*models.Property{{
+				Name: "someProp",
+				ModuleConfig: map[string]interface{}{
+					"my-module": map[string]interface{}{
+						"skip":                  false,
+						"vectorizePropertyName": false,
+					},
+				},
+			}},
+		}
+
+		cfg := modules.NewClassBasedModuleConfig(class, "my-module", "tenant")
+		ic := NewClassSettings(cfg)
+
+		assert.True(t, ic.PropertyIndexed("someProp"))
+		assert.False(t, ic.VectorizePropertyName("someProp"))
+		assert.True(t, ic.VectorizeClassName())
+		assert.Equal(t, ic.PoolingStrategy(), "masked_mean")
+	})
+
+	t.Run("with all explicit config using non-default values", func(t *testing.T) {
+		class := &models.Class{
+			Class: "MyClass",
+			ModuleConfig: map[string]interface{}{
+				"my-module": map[string]interface{}{
+					"vectorizeClassName": false,
+					"poolingStrategy":    "cls",
+				},
+			},
+			Properties: []*models.Property{{
+				Name: "someProp",
+				ModuleConfig: map[string]interface{}{
+					"my-module": map[string]interface{}{
+						"skip":                  true,
+						"vectorizePropertyName": true,
+					},
+				},
+			}},
+		}
+
+		cfg := modules.NewClassBasedModuleConfig(class, "my-module", "tenant")
+		ic := NewClassSettings(cfg)
+
+		assert.False(t, ic.PropertyIndexed("someProp"))
+		assert.True(t, ic.VectorizePropertyName("someProp"))
+		assert.False(t, ic.VectorizeClassName())
+		assert.Equal(t, ic.PoolingStrategy(), "cls")
+	})
+}

modules/text2vec-transformers/vectorizer/fakes_for_test.go

@@ -0,0 +1,85 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package vectorizer
+
+import (
+	"context"
+
+	"github.com/weaviate/weaviate/modules/text2vec-transformers/ent"
+)
+
+type fakeClient struct {
+	lastInput  string
+	lastConfig ent.VectorizationConfig
+}
+
+func (c *fakeClient) VectorizeObject(ctx context.Context,
+	text string, cfg ent.VectorizationConfig,
+) (*ent.VectorizationResult, error) {
+	c.lastInput = text
+	c.lastConfig = cfg
+	return &ent.VectorizationResult{
+		Vector:     []float32{0, 1, 2, 3},
+		Dimensions: 4,
+		Text:       text,
+	}, nil
+}
+
+func (c *fakeClient) VectorizeQuery(ctx context.Context,
+	text string, cfg ent.VectorizationConfig,
+) (*ent.VectorizationResult, error) {
+	return c.VectorizeObject(ctx, text, cfg)
+}
+
+type fakeClassConfig struct {
+	classConfig           map[string]interface{}
+	vectorizeClassName    bool
+	vectorizePropertyName bool
+	skippedProperty       string
+	excludedProperty      string
+	poolingStrategy       string
+}
+
+func (f fakeClassConfig) Class() map[string]interface{} {
+	classSettings := map[string]interface{}{
+		"vectorizeClassName": f.vectorizeClassName,
+		"poolingStrategy":    f.poolingStrategy,
+	}
+	return classSettings
+}
+
+func (f fakeClassConfig) ClassByModuleName(moduleName string) map[string]interface{} {
+	return f.classConfig
+}
+
+func (f fakeClassConfig) Property(propName string) map[string]interface{} {
+	if propName == f.skippedProperty {
+		return map[string]interface{}{
+			"skip": true,
+		}
+	}
+	if propName == f.excludedProperty {
+		return map[string]interface{}{
+			"vectorizePropertyName": false,
+		}
+	}
+	if f.vectorizePropertyName {
+		return map[string]interface{}{
+			"vectorizePropertyName": true,
+		}
+	}
+	return nil
+}
+
+func (f fakeClassConfig) Tenant() string {
+	return ""
+}

modules/text2vec-transformers/vectorizer/objects.go

@@ -0,0 +1,82 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package vectorizer
+
+import (
+	"context"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/moduletools"
+	"github.com/weaviate/weaviate/modules/text2vec-transformers/ent"
+	objectsvectorizer "github.com/weaviate/weaviate/usecases/modulecomponents/vectorizer"
+)
+
+type Vectorizer struct {
+	client           Client
+	objectVectorizer *objectsvectorizer.ObjectVectorizer
+}
+
+func New(client Client) *Vectorizer {
+	return &Vectorizer{
+		client:           client,
+		objectVectorizer: objectsvectorizer.New(),
+	}
+}
+
+type Client interface {
+	VectorizeObject(ctx context.Context, input string,
+		cfg ent.VectorizationConfig) (*ent.VectorizationResult, error)
+	VectorizeQuery(ctx context.Context, input string,
+		cfg ent.VectorizationConfig) (*ent.VectorizationResult, error)
+}
+
+// IndexCheck returns whether a property of a class should be indexed
+type ClassSettings interface {
+	PropertyIndexed(property string) bool
+	VectorizeClassName() bool
+	VectorizePropertyName(propertyName string) bool
+	PoolingStrategy() string
+}
+
+func (v *Vectorizer) Object(ctx context.Context, object *models.Object,
+	objDiff *moduletools.ObjectDiff, cfg moduletools.ClassConfig,
+) error {
+	vec, err := v.object(ctx, object.Class, object.Properties, objDiff, cfg)
+	if err != nil {
+		return err
+	}
+
+	object.Vector = vec
+	return nil
+}
+
+func (v *Vectorizer) object(ctx context.Context, className string,
+	schema interface{}, objDiff *moduletools.ObjectDiff, cfg moduletools.ClassConfig,
+) ([]float32, error) {
+	text, vector, err := v.objectVectorizer.TextsOrVector(ctx, className, schema, objDiff, NewClassSettings(cfg))
+	if err != nil {
+		return nil, err
+	}
+	if vector != nil {
+		// dont' re-vectorize
+		return vector, nil
+	}
+	// vectorize text
+	res, err := v.client.VectorizeObject(ctx, text, ent.VectorizationConfig{
+		PoolingStrategy: NewClassSettings(cfg).PoolingStrategy(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Vector, nil
+}

modules/text2vec-transformers/vectorizer/objects_test.go

@@ -0,0 +1,368 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package vectorizer
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/moduletools"
+)
+
+// These are mostly copy/pasted (with minimal additions) from the
+// text2vec-contextionary module
+func TestVectorizingObjects(t *testing.T) {
+	type testCase struct {
+		name                    string
+		input                   *models.Object
+		expectedClientCall      string
+		expectedPoolingStrategy string
+		noindex                 string
+		excludedProperty        string // to simulate a schema where property names aren't vectorized
+		excludedClass           string // to simulate a schema where class names aren't vectorized
+		poolingStrategy         string
+	}
+
+	tests := []testCase{
+		{
+			name: "empty object",
+			input: &models.Object{
+				Class: "Car",
+			},
+			poolingStrategy:         "cls",
+			expectedPoolingStrategy: "cls",
+			expectedClientCall:      "car",
+		},
+		{
+			name: "object with one string prop",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand": "Mercedes",
+				},
+			},
+			expectedClientCall: "car brand mercedes",
+		},
+
+		{
+			name: "object with one non-string prop",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"power": 300,
+				},
+			},
+			expectedClientCall: "car",
+		},
+
+		{
+			name: "object with a mix of props",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":  "best brand",
+					"power":  300,
+					"review": "a very great car",
+				},
+			},
+			expectedClientCall: "car brand best brand review a very great car",
+		},
+		{
+			name:    "with a noindexed property",
+			noindex: "review",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":  "best brand",
+					"power":  300,
+					"review": "a very great car",
+				},
+			},
+			expectedClientCall: "car brand best brand",
+		},
+
+		{
+			name:          "with the class name not vectorized",
+			excludedClass: "Car",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":  "best brand",
+					"power":  300,
+					"review": "a very great car",
+				},
+			},
+			expectedClientCall: "brand best brand review a very great car",
+		},
+
+		{
+			name:             "with a property name not vectorized",
+			excludedProperty: "review",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":  "best brand",
+					"power":  300,
+					"review": "a very great car",
+				},
+			},
+			expectedClientCall: "car brand best brand a very great car",
+		},
+
+		{
+			name:             "with no schema labels vectorized",
+			excludedProperty: "review",
+			excludedClass:    "Car",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"review": "a very great car",
+				},
+			},
+			expectedClientCall: "a very great car",
+		},
+
+		{
+			name:             "with string/text arrays without propname or classname",
+			excludedProperty: "reviews",
+			excludedClass:    "Car",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"reviews": []interface{}{
+						"a very great car",
+						"you should consider buying one",
+					},
+				},
+			},
+			expectedClientCall: "a very great car you should consider buying one",
+		},
+
+		{
+			name: "with string/text arrays with propname and classname",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"reviews": []interface{}{
+						"a very great car",
+						"you should consider buying one",
+					},
+				},
+			},
+			expectedClientCall: "car reviews a very great car reviews you should consider buying one",
+		},
+
+		{
+			name: "with compound class and prop names",
+			input: &models.Object{
+				Class: "SuperCar",
+				Properties: map[string]interface{}{
+					"brandOfTheCar": "best brand",
+					"power":         300,
+					"review":        "a very great car",
+				},
+			},
+			expectedClientCall: "super car brand of the car best brand review a very great car",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			client := &fakeClient{}
+
+			v := New(client)
+
+			ic := &fakeClassConfig{
+				excludedProperty:      test.excludedProperty,
+				skippedProperty:       test.noindex,
+				vectorizeClassName:    test.excludedClass != "Car",
+				poolingStrategy:       test.poolingStrategy,
+				vectorizePropertyName: true,
+			}
+			err := v.Object(context.Background(), test.input, nil, ic)
+
+			require.Nil(t, err)
+			assert.Equal(t, models.C11yVector{0, 1, 2, 3}, test.input.Vector)
+			expected := strings.Split(test.expectedClientCall, " ")
+			actual := strings.Split(client.lastInput, " ")
+			assert.Equal(t, expected, actual)
+			assert.Equal(t, client.lastConfig.PoolingStrategy, test.expectedPoolingStrategy)
+		})
+	}
+}
+
+func TestVectorizingObjectsWithDiff(t *testing.T) {
+	type testCase struct {
+		name              string
+		input             *models.Object
+		skipped           string
+		diff              *moduletools.ObjectDiff
+		expectedVectorize bool
+	}
+
+	tests := []testCase{
+		{
+			name: "no diff",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":       "best brand",
+					"power":       300,
+					"description": "a very great car",
+					"reviews": []interface{}{
+						"a very great car",
+						"you should consider buying one",
+					},
+				},
+			},
+			diff:              nil,
+			expectedVectorize: true,
+		},
+		{
+			name: "diff all props unchanged",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":       "best brand",
+					"power":       300,
+					"description": "a very great car",
+					"reviews": []interface{}{
+						"a very great car",
+						"you should consider buying one",
+					},
+				},
+			},
+			diff: newObjectDiffWithVector().
+				WithProp("brand", "best brand", "best brand").
+				WithProp("power", 300, 300).
+				WithProp("description", "a very great car", "a very great car").
+				WithProp("reviews", []interface{}{
+					"a very great car",
+					"you should consider buying one",
+				}, []interface{}{
+					"a very great car",
+					"you should consider buying one",
+				}),
+			expectedVectorize: false,
+		},
+		{
+			name: "diff one vectorizable prop changed (1)",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":       "best brand",
+					"power":       300,
+					"description": "a very great car",
+					"reviews": []interface{}{
+						"a very great car",
+						"you should consider buying one",
+					},
+				},
+			},
+			diff: newObjectDiffWithVector().
+				WithProp("brand", "old best brand", "best brand"),
+			expectedVectorize: true,
+		},
+		{
+			name: "diff one vectorizable prop changed (2)",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":       "best brand",
+					"power":       300,
+					"description": "a very great car",
+					"reviews": []interface{}{
+						"a very great car",
+						"you should consider buying one",
+					},
+				},
+			},
+			diff: newObjectDiffWithVector().
+				WithProp("description", "old a very great car", "a very great car"),
+			expectedVectorize: true,
+		},
+		{
+			name: "diff one vectorizable prop changed (3)",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":       "best brand",
+					"power":       300,
+					"description": "a very great car",
+					"reviews": []interface{}{
+						"a very great car",
+						"you should consider buying one",
+					},
+				},
+			},
+			diff: newObjectDiffWithVector().
+				WithProp("reviews", []interface{}{
+					"old a very great car",
+					"you should consider buying one",
+				}, []interface{}{
+					"a very great car",
+					"you should consider buying one",
+				}),
+			expectedVectorize: true,
+		},
+		{
+			name:    "all non-vectorizable props changed",
+			skipped: "description",
+			input: &models.Object{
+				Class: "Car",
+				Properties: map[string]interface{}{
+					"brand":       "best brand",
+					"power":       300,
+					"description": "a very great car",
+					"reviews": []interface{}{
+						"a very great car",
+						"you should consider buying one",
+					},
+				},
+			},
+			diff: newObjectDiffWithVector().
+				WithProp("power", 123, 300).
+				WithProp("description", "old a very great car", "a very great car"),
+			expectedVectorize: false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			ic := &fakeClassConfig{
+				skippedProperty: test.skipped,
+			}
+
+			client := &fakeClient{}
+			v := New(client)
+
+			err := v.Object(context.Background(), test.input, test.diff, ic)
+
+			require.Nil(t, err)
+			if test.expectedVectorize {
+				assert.Equal(t, models.C11yVector{0, 1, 2, 3}, test.input.Vector)
+				assert.NotEmpty(t, client.lastInput)
+			} else {
+				assert.Equal(t, models.C11yVector{0, 0, 0, 0}, test.input.Vector)
+				assert.Empty(t, client.lastInput)
+			}
+		})
+	}
+}
+
+func newObjectDiffWithVector() *moduletools.ObjectDiff {
+	return moduletools.NewObjectDiff([]float32{0, 0, 0, 0})
+}

modules/text2vec-transformers/vectorizer/texts.go

@@ -0,0 +1,38 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package vectorizer
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/entities/moduletools"
+	"github.com/weaviate/weaviate/modules/text2vec-transformers/ent"
+	libvectorizer "github.com/weaviate/weaviate/usecases/vectorizer"
+)
+
+func (v *Vectorizer) Texts(ctx context.Context, inputs []string,
+	cfg moduletools.ClassConfig,
+) ([]float32, error) {
+	vectors := make([][]float32, len(inputs))
+	for i := range inputs {
+		res, err := v.client.VectorizeQuery(ctx, inputs[i], ent.VectorizationConfig{
+			PoolingStrategy: NewClassSettings(cfg).PoolingStrategy(),
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "remote client vectorize")
+		}
+		vectors[i] = res.Vector
+	}
+
+	return libvectorizer.CombineVectors(vectors), nil
+}

modules/text2vec-transformers/vectorizer/texts_test.go

@@ -0,0 +1,94 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: [email protected]
+//
+
+package vectorizer
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// as used in the nearText searcher
+func TestVectorizingTexts(t *testing.T) {
+	type testCase struct {
+		name                    string
+		input                   []string
+		expectedPoolingStrategy string
+		poolingStrategy         string
+	}
+
+	tests := []testCase{
+		{
+			name:                    "single word",
+			input:                   []string{"hello"},
+			poolingStrategy:         "cls",
+			expectedPoolingStrategy: "cls",
+		},
+		{
+			name:                    "multiple words",
+			input:                   []string{"hello world, this is me!"},
+			poolingStrategy:         "cls",
+			expectedPoolingStrategy: "cls",
+		},
+
+		{
+			name:                    "multiple sentences (joined with a dot)",
+			input:                   []string{"this is sentence 1", "and here's number 2"},
+			poolingStrategy:         "cls",
+			expectedPoolingStrategy: "cls",
+		},
+
+		{
+			name:                    "multiple sentences already containing a dot",
+			input:                   []string{"this is sentence 1.", "and here's number 2"},
+			poolingStrategy:         "cls",
+			expectedPoolingStrategy: "cls",
+		},
+		{
+			name:                    "multiple sentences already containing a question mark",
+			input:                   []string{"this is sentence 1?", "and here's number 2"},
+			poolingStrategy:         "cls",
+			expectedPoolingStrategy: "cls",
+		},
+		{
+			name:                    "multiple sentences already containing an exclamation mark",
+			input:                   []string{"this is sentence 1!", "and here's number 2"},
+			poolingStrategy:         "cls",
+			expectedPoolingStrategy: "cls",
+		},
+		{
+			name:                    "multiple sentences already containing comma",
+			input:                   []string{"this is sentence 1,", "and here's number 2"},
+			poolingStrategy:         "cls",
+			expectedPoolingStrategy: "cls",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			client := &fakeClient{}
+
+			v := New(client)
+
+			settings := &fakeClassConfig{
+				poolingStrategy: test.poolingStrategy,
+			}
+			vec, err := v.Texts(context.Background(), test.input, settings)
+
+			require.Nil(t, err)
+			assert.Equal(t, []float32{0, 1, 2, 3}, vec)
+			assert.Equal(t, client.lastConfig.PoolingStrategy, test.expectedPoolingStrategy)
+		})
+	}
+}