diff --git a/pom.xml b/pom.xml
index 7e3b0b9432..095909aa61 100644
--- a/pom.xml
+++ b/pom.xml
@@ -5,7 +5,7 @@
org.springframework.dataspring-data-mongodb-parent
- 4.5.0-SNAPSHOT
+ 4.5.x-GH-4706-SNAPSHOTpomSpring Data MongoDB
@@ -26,8 +26,8 @@
multispring-data-mongodb
- 3.5.0-SNAPSHOT
- 5.3.0-beta0
+ 3.5.0-GH-3193-SNAPSHOT
+ 5.3.0${mongo}${mongo}1.19
diff --git a/spring-data-mongodb-distribution/pom.xml b/spring-data-mongodb-distribution/pom.xml
index 58c63dfc97..e382c300b9 100644
--- a/spring-data-mongodb-distribution/pom.xml
+++ b/spring-data-mongodb-distribution/pom.xml
@@ -15,7 +15,7 @@
org.springframework.dataspring-data-mongodb-parent
- 4.5.0-SNAPSHOT
+ 4.5.x-GH-4706-SNAPSHOT../pom.xml
diff --git a/spring-data-mongodb/pom.xml b/spring-data-mongodb/pom.xml
index 98516a5ba9..236d6d7680 100644
--- a/spring-data-mongodb/pom.xml
+++ b/spring-data-mongodb/pom.xml
@@ -13,7 +13,7 @@
org.springframework.dataspring-data-mongodb-parent
- 4.5.0-SNAPSHOT
+ 4.5.x-GH-4706-SNAPSHOT../pom.xml
@@ -131,6 +131,13 @@
true
+
+ org.awaitility
+ awaitility
+ 4.2.2
+ test
+
+
io.reactivex.rxjava3rxjava
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultIndexOperations.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultIndexOperations.java
index c25804e8e5..d23e08a20b 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultIndexOperations.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultIndexOperations.java
@@ -20,7 +20,6 @@
import java.util.List;
import org.bson.Document;
-
import org.springframework.dao.DataAccessException;
import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.data.mongodb.UncategorizedMongoDbException;
@@ -51,11 +50,11 @@ public class DefaultIndexOperations implements IndexOperations {
private static final String PARTIAL_FILTER_EXPRESSION_KEY = "partialFilterExpression";
- private final String collectionName;
- private final QueryMapper mapper;
- private final @Nullable Class type;
+ protected final String collectionName;
+ protected final QueryMapper mapper;
+ protected final @Nullable Class type;
- private final MongoOperations mongoOperations;
+ protected final MongoOperations mongoOperations;
/**
* Creates a new {@link DefaultIndexOperations}.
@@ -133,7 +132,7 @@ public String ensureIndex(IndexDefinition indexDefinition) {
}
@Nullable
- private MongoPersistentEntity lookupPersistentEntity(@Nullable Class entityType, String collection) {
+ protected MongoPersistentEntity lookupPersistentEntity(@Nullable Class entityType, String collection) {
if (entityType != null) {
return mapper.getMappingContext().getRequiredPersistentEntity(entityType);
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java
index b984c379c6..fd05cd5b1f 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java
@@ -85,10 +85,13 @@
import org.springframework.data.mongodb.core.convert.MongoWriter;
import org.springframework.data.mongodb.core.convert.QueryMapper;
import org.springframework.data.mongodb.core.convert.UpdateMapper;
+import org.springframework.data.mongodb.core.index.DefaultSearchIndexOperations;
import org.springframework.data.mongodb.core.index.IndexOperations;
import org.springframework.data.mongodb.core.index.IndexOperationsProvider;
import org.springframework.data.mongodb.core.index.MongoMappingEventPublisher;
import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexCreator;
+import org.springframework.data.mongodb.core.index.SearchIndexOperations;
+import org.springframework.data.mongodb.core.index.SearchIndexOperationsProvider;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
@@ -182,8 +185,8 @@
* @author Michael Krog
* @author Jakub Zurawa
*/
-public class MongoTemplate
- implements MongoOperations, ApplicationContextAware, IndexOperationsProvider, ReadPreferenceAware {
+public class MongoTemplate implements MongoOperations, ApplicationContextAware, IndexOperationsProvider,
+ SearchIndexOperationsProvider, ReadPreferenceAware {
private static final Log LOGGER = LogFactory.getLog(MongoTemplate.class);
private static final WriteResultChecking DEFAULT_WRITE_RESULT_CHECKING = WriteResultChecking.NONE;
@@ -768,6 +771,21 @@ public IndexOperations indexOps(Class entityClass) {
return indexOps(getCollectionName(entityClass), entityClass);
}
+ @Override
+ public SearchIndexOperations searchIndexOps(String collectionName) {
+ return searchIndexOps(null, collectionName);
+ }
+
+ @Override
+ public SearchIndexOperations searchIndexOps(Class type) {
+ return new DefaultSearchIndexOperations(this, type);
+ }
+
+ @Override
+ public SearchIndexOperations searchIndexOps(@Nullable Class type, String collectionName) {
+ return new DefaultSearchIndexOperations(this, collectionName, type);
+ }
+
@Override
public BulkOperations bulkOps(BulkMode mode, String collectionName) {
return bulkOps(mode, null, collectionName);
@@ -1313,7 +1331,7 @@ private WriteConcern potentiallyForceAcknowledgedWrite(@Nullable WriteConcern wc
if (ObjectUtils.nullSafeEquals(WriteResultChecking.EXCEPTION, writeResultChecking)) {
if (wc == null || wc.getWObject() == null
- || (wc.getWObject()instanceof Number concern && concern.intValue() < 1)) {
+ || (wc.getWObject() instanceof Number concern && concern.intValue() < 1)) {
return WriteConcern.ACKNOWLEDGED;
}
}
@@ -1965,7 +1983,8 @@ public List mapReduce(Query query, Class domainType, String inputColle
}
if (mapReduceOptions.getOutputSharded().isPresent()) {
- MongoCompatibilityAdapter.mapReduceIterableAdapter(mapReduce).sharded(mapReduceOptions.getOutputSharded().get());
+ MongoCompatibilityAdapter.mapReduceIterableAdapter(mapReduce)
+ .sharded(mapReduceOptions.getOutputSharded().get());
}
if (StringUtils.hasText(mapReduceOptions.getOutputCollection()) && !mapReduceOptions.usesInlineOutput()) {
@@ -2064,7 +2083,7 @@ public List findAllAndRemove(Query query, Class entityClass, String co
}
@Override
- public UpdateResult replace(Query query, T replacement, ReplaceOptions options, String collectionName){
+ public UpdateResult replace(Query query, T replacement, ReplaceOptions options, String collectionName) {
Assert.notNull(replacement, "Replacement must not be null");
return replace(query, (Class) ClassUtils.getUserClass(replacement), replacement, options, collectionName);
@@ -2740,8 +2759,7 @@ protected T doFindAndModify(CollectionPreparer collectionPreparer, String co
LOGGER.debug(String.format(
"findAndModify using query: %s fields: %s sort: %s for class: %s and update: %s in collection: %s",
serializeToJsonSafely(mappedQuery), fields, serializeToJsonSafely(sort), entityClass,
- serializeToJsonSafely(mappedUpdate),
- collectionName));
+ serializeToJsonSafely(mappedUpdate), collectionName));
}
return executeFindOneInternal(
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/Aggregation.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/Aggregation.java
index f3984f3fdc..45de38ed21 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/Aggregation.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/Aggregation.java
@@ -381,9 +381,9 @@ public static UnwindOperation unwind(String field, String arrayIndex) {
}
/**
- * Factory method to create a new {@link UnwindOperation} for the field with the given name, including the name of a new
- * field to hold the array index of the element as {@code arrayIndex} using {@code preserveNullAndEmptyArrays}. Note
- * that extended unwind is supported in MongoDB version 3.2+.
+ * Factory method to create a new {@link UnwindOperation} for the field with the given name, including the name of a
+ * new field to hold the array index of the element as {@code arrayIndex} using {@code preserveNullAndEmptyArrays}.
+ * Note that extended unwind is supported in MongoDB version 3.2+.
*
* @param field must not be {@literal null} or empty.
* @param arrayIndex must not be {@literal null} or empty.
@@ -428,6 +428,20 @@ public static StartWithBuilder graphLookup(String fromCollection) {
return GraphLookupOperation.builder().from(fromCollection);
}
+ /**
+ * Creates a new {@link VectorSearchOperation} by starting from the {@code indexName} to use.
+ *
+ * @param indexName must not be {@literal null} or empty.
+ * @return new instance of {@link VectorSearchOperation.PathContributor}.
+ * @since 4.5
+ */
+ public static VectorSearchOperation.PathContributor vectorSearch(String indexName) {
+
+ Assert.hasText(indexName, "Index name must not be null or empty");
+
+ return VectorSearchOperation.search(indexName);
+ }
+
/**
* Factory method to create a new {@link SortOperation} for the given {@link Sort}.
*
@@ -669,14 +683,14 @@ public static LookupOperation lookup(Field from, Field localField, Field foreign
/**
* Entrypoint for creating {@link LookupOperation $lookup} using a fluent builder API.
+ *
*
+ *
* @return new instance of {@link LookupOperationBuilder}.
* @since 4.1
*/
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/VectorSearchOperation.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/VectorSearchOperation.java
new file mode 100644
index 0000000000..c7d984d470
--- /dev/null
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/VectorSearchOperation.java
@@ -0,0 +1,528 @@
+/*
+ * Copyright 2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.aggregation;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+import org.bson.BinaryVector;
+import org.bson.Document;
+
+import org.springframework.data.domain.Limit;
+import org.springframework.data.domain.Vector;
+import org.springframework.data.mongodb.core.mapping.MongoVector;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.CriteriaDefinition;
+import org.springframework.lang.Contract;
+import org.springframework.lang.Nullable;
+import org.springframework.util.StringUtils;
+
+/**
+ * Performs a semantic search on data in your Atlas cluster. This stage is only available for Atlas Vector Search.
+ * Vector data must be less than or equal to 4096 dimensions in width.
+ *
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 4.5
+ */
+public class VectorSearchOperation implements AggregationOperation {
+
+ private final SearchType searchType;
+ private final @Nullable CriteriaDefinition filter;
+ private final String indexName;
+ private final Limit limit;
+ private final @Nullable Integer numCandidates;
+ private final QueryPaths path;
+ private final Vector vector;
+ private final String score;
+ private final Consumer scoreCriteria;
+
+ private VectorSearchOperation(SearchType searchType, @Nullable CriteriaDefinition filter, String indexName,
+ Limit limit, @Nullable Integer numCandidates, QueryPaths path, Vector vector, @Nullable String searchScore,
+ Consumer scoreCriteria) {
+
+ this.searchType = searchType;
+ this.filter = filter;
+ this.indexName = indexName;
+ this.limit = limit;
+ this.numCandidates = numCandidates;
+ this.path = path;
+ this.vector = vector;
+ this.score = searchScore;
+ this.scoreCriteria = scoreCriteria;
+ }
+
+ VectorSearchOperation(String indexName, QueryPaths path, Limit limit, Vector vector) {
+ this(SearchType.DEFAULT, null, indexName, limit, null, path, vector, null, null);
+ }
+
+ /**
+ * Entrypoint to build a {@link VectorSearchOperation} starting from the {@code index} name to search. Atlas Vector
+ * Search doesn't return results if you misspell the index name or if the specified index doesn't already exist on the
+ * cluster.
+ *
+ * @param index must not be {@literal null} or empty.
+ * @return new instance of {@link VectorSearchOperation.PathContributor}.
+ */
+ public static PathContributor search(String index) {
+ return new VectorSearchBuilder().index(index);
+ }
+
+ /**
+ * Configure the search type to use. {@link SearchType#ENN} leads to an exact search while {@link SearchType#ANN} uses
+ * {@code exact=false}.
+ *
+ * @param searchType must not be null.
+ * @return a new {@link VectorSearchOperation} with {@link SearchType} applied.
+ */
+ @Contract("_ -> new")
+ public VectorSearchOperation searchType(SearchType searchType) {
+ return new VectorSearchOperation(searchType, filter, indexName, limit, numCandidates, path, vector, score,
+ scoreCriteria);
+ }
+
+ /**
+ * Criteria expression that compares an indexed field with a boolean, date, objectId, number (not decimals), string,
+ * or UUID to use as a pre-filter.
+ *
+ * Atlas Vector Search supports only the filters for the following MQL match expressions:
+ *
+ *
$gt
+ *
$lt
+ *
$gte
+ *
$lte
+ *
$eq
+ *
$ne
+ *
$in
+ *
$nin
+ *
$nor
+ *
$not
+ *
$and
+ *
$or
+ *
+ *
+ * @param filter must not be null.
+ * @return a new {@link VectorSearchOperation} with {@link CriteriaDefinition} applied.
+ */
+ @Contract("_ -> new")
+ public VectorSearchOperation filter(CriteriaDefinition filter) {
+ return new VectorSearchOperation(searchType, filter, indexName, limit, numCandidates, path, vector, score,
+ scoreCriteria);
+ }
+
+ /**
+ * Criteria expression that compares an indexed field with a boolean, date, objectId, number (not decimals), string,
+ * or UUID to use as a pre-filter.
+ *
+ * Atlas Vector Search supports only the filters for the following MQL match expressions:
+ *
+ *
$gt
+ *
$lt
+ *
$gte
+ *
$lte
+ *
$eq
+ *
$ne
+ *
$in
+ *
$nin
+ *
$nor
+ *
$not
+ *
$and
+ *
$or
+ *
+ *
+ * @param filter must not be null.
+ * @return a new {@link VectorSearchOperation} with {@link CriteriaDefinition} applied.
+ */
+ @Contract("_ -> new")
+ public VectorSearchOperation filter(Document filter) {
+
+ return filter(new CriteriaDefinition() {
+ @Override
+ public Document getCriteriaObject() {
+ return filter;
+ }
+
+ @Nullable
+ @Override
+ public String getKey() {
+ return null;
+ }
+ });
+ }
+
+ /**
+ * Number of nearest neighbors to use during the search. Value must be less than or equal to (<=) {@code 10000}. You
+ * can't specify a number less than the number of documents to return (limit). This field is required if
+ * {@link #searchType(SearchType)} is {@link SearchType#ANN} or {@link SearchType#DEFAULT}.
+ *
+ * @param numCandidates
+ * @return a new {@link VectorSearchOperation} with {@code numCandidates} applied.
+ */
+ @Contract("_ -> new")
+ public VectorSearchOperation numCandidates(int numCandidates) {
+ return new VectorSearchOperation(searchType, filter, indexName, limit, numCandidates, path, vector, score,
+ scoreCriteria);
+ }
+
+ /**
+ * Add a {@link AddFieldsOperation} stage including the search score using {@code score} as field name.
+ *
+ * @return a new {@link VectorSearchOperation} with search score applied.
+ * @see #withSearchScore(String)
+ */
+ @Contract("-> new")
+ public VectorSearchOperation withSearchScore() {
+ return withSearchScore("score");
+ }
+
+ /**
+ * Add a {@link AddFieldsOperation} stage including the search score using {@code scoreFieldName} as field name.
+ *
+ * @param scoreFieldName name of the score field.
+ * @return a new {@link VectorSearchOperation} with {@code scoreFieldName} applied.
+ * @see #withSearchScore()
+ */
+ @Contract("_ -> new")
+ public VectorSearchOperation withSearchScore(String scoreFieldName) {
+ return new VectorSearchOperation(searchType, filter, indexName, limit, numCandidates, path, vector, scoreFieldName,
+ scoreCriteria);
+ }
+
+ /**
+ * Add a {@link MatchOperation} stage targeting the score field name. Implies that the score field is present by
+ * either reusing a previous {@link AddFieldsOperation} from {@link #withSearchScore()} or
+ * {@link #withSearchScore(String)} or by adding a new {@link AddFieldsOperation} stage.
+ *
+ * @return a new {@link VectorSearchOperation} with search score filter applied.
+ */
+ @Contract("_ -> new")
+ public VectorSearchOperation withFilterBySore(Consumer score) {
+ return new VectorSearchOperation(searchType, filter, indexName, limit, numCandidates, path, vector,
+ StringUtils.hasText(this.score) ? this.score : "score", score);
+ }
+
+ @Override
+ public Document toDocument(AggregationOperationContext context) {
+
+ Document $vectorSearch = new Document();
+
+ if (searchType != null && !searchType.equals(SearchType.DEFAULT)) {
+ $vectorSearch.append("exact", searchType.equals(SearchType.ENN));
+ }
+
+ if (filter != null) {
+ $vectorSearch.append("filter", context.getMappedObject(filter.getCriteriaObject()));
+ }
+
+ $vectorSearch.append("index", indexName);
+ $vectorSearch.append("limit", limit.max());
+
+ if (numCandidates != null) {
+ $vectorSearch.append("numCandidates", numCandidates);
+ }
+
+ Object path = this.path.getPathObject();
+
+ if (path instanceof String pathFieldName) {
+ Document mappedObject = context.getMappedObject(new Document(pathFieldName, 1));
+ path = mappedObject.keySet().iterator().next();
+ }
+
+ Object source = vector.getSource();
+
+ if (source instanceof float[]) {
+ source = vector.toDoubleArray();
+ }
+
+ if (source instanceof double[] ds) {
+ source = Arrays.stream(ds).boxed().collect(Collectors.toList());
+ }
+
+ $vectorSearch.append("path", path);
+ $vectorSearch.append("queryVector", source);
+
+ return new Document(getOperator(), $vectorSearch);
+ }
+
+ @Override
+ public List toPipelineStages(AggregationOperationContext context) {
+
+ if (!StringUtils.hasText(score)) {
+ return List.of(toDocument(context));
+ }
+
+ AddFieldsOperation $vectorSearchScore = Aggregation.addFields().addField(score)
+ .withValueOfExpression("{\"$meta\":\"vectorSearchScore\"}").build();
+
+ if (scoreCriteria == null) {
+ return List.of(toDocument(context), $vectorSearchScore.toDocument(context));
+ }
+
+ Criteria criteria = Criteria.where(score);
+ scoreCriteria.accept(criteria);
+ MatchOperation $filterByScore = Aggregation.match(criteria);
+
+ return List.of(toDocument(context), $vectorSearchScore.toDocument(context), $filterByScore.toDocument(context));
+ }
+
+ @Override
+ public String getOperator() {
+ return "$vectorSearch";
+ }
+
+ /**
+ * Builder helper to create a {@link VectorSearchOperation}.
+ */
+ private static class VectorSearchBuilder implements PathContributor, VectorContributor, LimitContributor {
+
+ String index;
+ QueryPath paths;
+ Vector vector;
+
+ PathContributor index(String index) {
+ this.index = index;
+ return this;
+ }
+
+ @Override
+ public VectorContributor path(String path) {
+
+ this.paths = QueryPath.path(path);
+ return this;
+ }
+
+ @Override
+ public VectorSearchOperation limit(Limit limit) {
+ return new VectorSearchOperation(index, QueryPaths.of(paths), limit, vector);
+ }
+
+ @Override
+ public LimitContributor vector(Vector vector) {
+ this.vector = vector;
+ return this;
+ }
+ }
+
+ /**
+ * Search type, ANN as approximation or ENN for exact search.
+ */
+ public enum SearchType {
+
+ /** MongoDB Server default (value will be omitted) */
+ DEFAULT,
+ /** Approximate Nearest Neighbour */
+ ANN,
+ /** Exact Nearest Neighbour */
+ ENN
+ }
+
+ // A query path cannot only contain the name of the filed but may also hold additional information about the
+ // analyzer to use;
+ // "path": [ "names", "notes", { "value": "comments", "multi": "mySecondaryAnalyzer" } ]
+ // see: https://www.mongodb.com/docs/atlas/atlas-search/path-construction/#std-label-ref-path
+ public static class QueryPaths {
+
+ Set> paths;
+
+ public static QueryPaths of(QueryPath path) {
+
+ QueryPaths queryPaths = new QueryPaths();
+ queryPaths.paths = new LinkedHashSet<>(2);
+ queryPaths.paths.add(path);
+ return queryPaths;
+ }
+
+ Object getPathObject() {
+
+ if (paths.size() == 1) {
+ return paths.iterator().next().value();
+ }
+ return paths.stream().map(QueryPath::value).collect(Collectors.toList());
+ }
+ }
+
+ public interface QueryPath {
+
+ T value();
+
+ static QueryPath path(String field) {
+ return new SimplePath(field);
+ }
+
+ static QueryPath> wildcard(String field) {
+ return new WildcardPath(field);
+ }
+
+ static QueryPath> multi(String field, String analyzer) {
+ return new MultiPath(field, analyzer);
+ }
+ }
+
+ public static class SimplePath implements QueryPath {
+
+ String name;
+
+ public SimplePath(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public String value() {
+ return name;
+ }
+ }
+
+ public static class WildcardPath implements QueryPath> {
+
+ String name;
+
+ public WildcardPath(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public Map value() {
+ return Map.of("wildcard", name);
+ }
+ }
+
+ public static class MultiPath implements QueryPath> {
+
+ String field;
+ String analyzer;
+
+ public MultiPath(String field, String analyzer) {
+ this.field = field;
+ this.analyzer = analyzer;
+ }
+
+ @Override
+ public Map value() {
+ return Map.of("value", field, "multi", analyzer);
+ }
+ }
+
+ public interface PathContributor {
+
+ /**
+ * Indexed vector type field to search.
+ *
+ * @param path name of the search path.
+ * @return
+ */
+ @Contract("_ -> this")
+ VectorContributor path(String path);
+ }
+
+ public interface VectorContributor {
+
+ /**
+ * Array of float numbers that represent the query vector. The number type must match the indexed field value type.
+ * Otherwise, Atlas Vector Search doesn't return any results or errors.
+ *
+ * @param vector the query vector.
+ * @return
+ */
+ @Contract("_ -> this")
+ default LimitContributor vector(float... vector) {
+ return vector(Vector.of(vector));
+ }
+
+ /**
+ * Array of double numbers that represent the query vector. The number type must match the indexed field value type.
+ * Otherwise, Atlas Vector Search doesn't return any results or errors.
+ *
+ * @param vector the query vector.
+ * @return
+ */
+ @Contract("_ -> this")
+ default LimitContributor vector(double... vector) {
+ return vector(Vector.of(vector));
+ }
+
+ /**
+ * Array of numbers that represent the query vector. The number type must match the indexed field value type.
+ * Otherwise, Atlas Vector Search doesn't return any results or errors.
+ *
+ * @param vector the query vector.
+ * @return
+ */
+ @Contract("_ -> this")
+ default LimitContributor vector(List vector) {
+ return vector(Vector.of(vector));
+ }
+
+ /**
+ * Binary vector (BSON BinData vector subtype float32, or BSON BinData vector subtype int1 or int8 type) that
+ * represent the query vector. The number type must match the indexed field value type. Otherwise, Atlas Vector
+ * Search doesn't return any results or errors.
+ *
+ * @param vector the query vector.
+ * @return
+ */
+ @Contract("_ -> this")
+ default LimitContributor vector(BinaryVector vector) {
+ return vector(MongoVector.of(vector));
+ }
+
+ /**
+ * The query vector. The number type must match the indexed field value type. Otherwise, Atlas Vector Search doesn't
+ * return any results or errors.
+ *
+ * @param vector the query vector.
+ * @return
+ */
+ @Contract("_ -> this")
+ LimitContributor vector(Vector vector);
+ }
+
+ public interface LimitContributor {
+
+ /**
+ * Number (of type int only) of documents to return in the results. This value can't exceed the value of
+ * numCandidates if you specify numCandidates.
+ *
+ * @param limit
+ * @return
+ */
+ @Contract("_ -> this")
+ default VectorSearchOperation limit(int limit) {
+ return limit(Limit.of(limit));
+ }
+
+ /**
+ * Number (of type int only) of documents to return in the results. This value can't exceed the value of
+ * numCandidates if you specify numCandidates.
+ *
+ * @param limit
+ * @return
+ */
+ @Contract("_ -> this")
+ VectorSearchOperation limit(Limit limit);
+ }
+
+}
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java
index 46dc22d99a..d9f6ca43be 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java
@@ -31,6 +31,9 @@
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
+import org.bson.BinaryVector;
+import org.bson.BsonArray;
+import org.bson.BsonDouble;
import org.bson.BsonReader;
import org.bson.BsonTimestamp;
import org.bson.BsonUndefined;
@@ -44,6 +47,7 @@
import org.bson.types.Code;
import org.bson.types.Decimal128;
import org.bson.types.ObjectId;
+
import org.springframework.core.convert.ConversionFailedException;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.core.convert.converter.ConditionalConverter;
@@ -51,7 +55,9 @@
import org.springframework.core.convert.converter.ConverterFactory;
import org.springframework.data.convert.ReadingConverter;
import org.springframework.data.convert.WritingConverter;
+import org.springframework.data.domain.Vector;
import org.springframework.data.mongodb.core.mapping.FieldName;
+import org.springframework.data.mongodb.core.mapping.MongoVector;
import org.springframework.data.mongodb.core.query.Term;
import org.springframework.data.mongodb.core.script.NamedMongoScript;
import org.springframework.util.Assert;
@@ -106,6 +112,10 @@ static Collection