def test_multi_search_check_vector(self):
        """check the result vector in the body is the same as one we manually calculate

        This checks our batching logic.
        """
        docs = [
            {
                "loc a": TestImageUrls.HIPPO_REALISTIC.value,
                "_id": 'realistic_hippo'},
            {"loc a": TestImageUrls.HIPPO_STATUE.value,
             "_id": 'artefact_hippo'}
        ]
        image_index_config = {
            IndexSettingsField.index_defaults: {
                IndexSettingsField.model: "ViT-B/16",
                IndexSettingsField.treatUrlsAndPointersAsImages: True
            }
        }
        tensor_search.delete_index(self.config, self.index_name_1)
        tensor_search.create_vector_index(
            config=self.config, index_name=self.index_name_1, index_settings=image_index_config)
        add_docs_caller(
            config=self.config, index_name=self.index_name_1,
            docs=docs, auto_refresh=True
        )
        multi_queries = [
            {
                TestImageUrls.HIPPO_STATUE.value: 2.0,
                TestImageUrls.HIPPO_REALISTIC.value: -1.0,
                "artefact": 5.0, "photo realistic": -1,
            },
            {
                "artefact": 5.0,
                TestImageUrls.HIPPO_STATUE.value: 2.0,
                "photo realistic": -1,
                TestImageUrls.HIPPO_REALISTIC.value: -1.0
            },
            {
                TestImageUrls.HIPPO_STATUE.value: 3,
                TestImageUrls.HIPPO_REALISTIC.value: -1.0,
            },
            {
                "hello": 3, "some thing": -1.0,
            },
        ]
        from marqo.tensor_search.utils import dicts_to_jsonl

        for multi_query in multi_queries:
            mock_dicts_to_jsonl = mock.MagicMock()
            mock_dicts_to_jsonl.side_effect = lambda *x, **y: dicts_to_jsonl(*x, **y)

            @mock.patch('marqo.tensor_search.utils.dicts_to_jsonl', mock_dicts_to_jsonl)
            def run() -> typing.List[float]:
                tensor_search.search(
                    text=multi_query,
                    index_name=self.index_name_1,
                    result_count=5,
                    config=self.config,
                    search_method=SearchMethod.TENSOR)
                get_args, get_kwargs = mock_dicts_to_jsonl.call_args
                search_dicts = get_args[0]
                assert len(search_dicts) == 2
                query_dict = search_dicts[1]

                query_vec = query_dict['query']['nested']['query']['knn'][
                    f"{TensorField.chunks}.{TensorField.marqo_knn_field}"]['vector']
                return query_vec

            # manually calculate weights:
            weighted_vectors = []
            for q, weight in multi_query.items():
                vec = vectorise(model_name="ViT-B/16", content=[q, ],
                                media_download_headers=None, normalize_embeddings=True,
                                device="cpu")[0]
                weighted_vectors.append(np.asarray(vec) * weight)

            manually_combined = np.mean(weighted_vectors, axis=0)
            norm = np.linalg.norm(manually_combined, axis=-1, keepdims=True)
            if norm > 0:
                manually_combined /= np.linalg.norm(manually_combined, axis=-1, keepdims=True)
            manually_combined = list(manually_combined)

            combined_query = run()
            assert np.allclose(combined_query, manually_combined, atol=1e-6)
check the result vector in the body is the same as one we manually calculate

        This checks our batching logic.
        
tests/integ_tests/tensor_search/test_search.py