@mastra/mongodb 1.18.10 → 1.19.0-alpha.0

package/dist/index.js

@@ -9,7 +9,7 @@ import { MessageList } from "@mastra/core/agent";
 import { saveScorePayloadSchema } from "@mastra/core/evals";
 import { skillSnapshotFieldValuesEqual } from "@mastra/core/storage/domains/skills";
 //#region package.json
-var version = "1.18.10";
+var version = "1.19.0-alpha.0";
 //#endregion
 //#region src/vector/filter.ts
 /**
@@ -81,6 +81,10 @@ var MongoDBFilterTranslator = class extends BaseFilterTranslator {
 };
 //#endregion
 //#region src/vector/index.ts
+/** Name an index's embedding mode for a conflict message. */
+function describeEmbedding(config) {
+	return config ? `autoEmbed (path "${config.path}", model "${config.model}")` : "client-side vectors";
+}
 var MongoDBVector = class MongoDBVector extends MastraVector {
 	client;
 	db;
@@ -185,7 +189,8 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 				searchIndexName: persisted.searchIndexName ?? `${indexName}_vector_index`,
 				isByo,
 				allowWrites: isByo ? persisted.allowWrites ?? false : true,
-				textSearchIndexName: persisted.textSearchIndexName
+				textSearchIndexName: persisted.textSearchIndexName,
+				autoEmbed: persisted.autoEmbed
 			};
 			this.indexTargets.set(indexName, target);
 			return {
@@ -288,9 +293,17 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	* Persist (upsert) a logical-index target so it survives a process restart. Idempotent
 	* createIndex refreshes it; a partial update (e.g. only the text-search-index name) merges
 	* into the existing entry.
+	*
+	* `claim` narrows the upsert to entries the caller considers compatible. Because the filter
+	* still pins `_id`, an incompatible entry matches nothing, the upsert attempts an insert, and
+	* the duplicate `_id` surfaces as a duplicate-key error (code 11000) instead of overwriting
+	* the entry someone else registered. Callers that only refresh part of an entry omit it.
 	*/
-	async writeRegistryEntry(indexName, entry) {
-		await this.db.collection(MongoDBVector.REGISTRY_COLLECTION).updateOne({ _id: indexName }, { $set: {
+	async writeRegistryEntry(indexName, entry, claim) {
+		await this.db.collection(MongoDBVector.REGISTRY_COLLECTION).updateOne({
+			_id: indexName,
+			...claim
+		}, { $set: {
 			indexName,
 			...entry
 		} }, { upsert: true });
@@ -324,6 +337,31 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 			text: `hybridQuery uses $rankFusion, which requires MongoDB >= 8.0 (found ${this.rankFusionSupport.version}). On 8.0.x it may need a MongoDB support case to enable; upgrade to >= 8.1, or run query() and textQuery() separately and fuse client-side.`
 		});
 	}
+	/** Validates a text upsert: `documents` is present, and `metadata`/`ids` line up with it. */
+	validateTextUpsertInput(indexName, documents, vectors, metadata, ids) {
+		const fail = (errorType, message, details = {}) => {
+			throw new MastraError({
+				id: createVectorErrorId("MONGODB", "UPSERT", errorType),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				text: message,
+				details: {
+					indexName,
+					...details
+				}
+			});
+		};
+		if (vectors?.length) fail("INVALID_ARGS", `Index "${indexName}" was created with autoEmbed, so MongoDB generates the embeddings: pass documents only. The supplied vectors would be stored in a field no index reads.`);
+		if (!documents || documents.length === 0) fail("EMPTY_DOCUMENTS", "documents array cannot be empty when upserting into an autoEmbed index");
+		if (metadata && metadata.length > 0 && metadata.length !== documents.length) fail("METADATA_LENGTH_MISMATCH", "Metadata array length must match documents array length", {
+			documentsLength: documents.length,
+			metadataLength: metadata.length
+		});
+		if (ids && ids.length !== documents.length) fail("IDS_LENGTH_MISMATCH", "IDs array length must match documents array length", {
+			documentsLength: documents.length,
+			idsLength: ids.length
+		});
+	}
 	/**
 	* Builds the projection pipeline stage(s) for query results based on metadata mode and
 	* whether to include vectors. Shared across query, textQuery, and hybridQuery to keep
@@ -350,7 +388,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	* @param scoreMeta - metadata field holding the relevance score for the search stage in use
 	*   (`vectorSearchScore` for $vectorSearch, `searchScore` for $search, `score` for $rankFusion).
 	*/
-	buildProjection(metadataMode, includeVector, scoreMeta) {
+	buildProjection(metadataMode, includeVector, scoreMeta, documentPath = this.documentFieldName) {
 		const score = { $meta: scoreMeta };
 		if (metadataMode === "document") {
 			const project = {
@@ -366,7 +404,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 			_id: 1,
 			score,
 			metadata: `$${this.metadataFieldName}`,
-			document: `$${this.documentFieldName}`,
+			document: `$${documentPath}`,
 			...includeVector && { vector: `$${this.embeddingFieldName}` }
 		} }];
 	}
@@ -403,10 +441,14 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	* queryable. Skipping that step on a real Atlas cluster may cause
 	* "index not found" or "index not ready" errors on subsequent operations.
 	*/
-	async createIndex({ indexName, dimension, metric = "cosine", filterFields, collectionName, searchIndexName, allowWrites }) {
+	async createIndex(params) {
+		const { indexName, dimension, metric = "cosine", filterFields, collectionName, searchIndexName, allowWrites, autoEmbed } = params;
 		let mongoMetric;
 		try {
-			if (!Number.isInteger(dimension) || dimension <= 0) throw new Error("Dimension must be a positive integer");
+			if (autoEmbed) {
+				if (dimension !== void 0) throw new Error("dimension cannot be combined with autoEmbed. The embedding model determines the vector size; use autoEmbed.numDimensions to override it.");
+				if (params.metric !== void 0) throw new Error("metric cannot be combined with autoEmbed. metric configures a client-side vector field; use autoEmbed.similarity instead.");
+			} else if (dimension === void 0 || !Number.isInteger(dimension) || dimension <= 0) throw new Error("Dimension must be a positive integer");
 			mongoMetric = this.mongoMetricMap[metric];
 			if (!mongoMetric) throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
 		} catch (error) {
@@ -416,7 +458,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 				category: ErrorCategory.USER,
 				details: {
 					indexName,
-					dimension,
+					...dimension !== void 0 ? { dimension } : {},
 					metric
 				}
 			}, error);
@@ -456,40 +498,87 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 				text: `searchIndexName "${targetSearchIndex}" collides with the full-text search index name for collection "${targetCollection}". Choose a different vector searchIndexName.`
 			});
 			const textSearchIndexName = effectiveIsByo ? existingEntry?.textSearchIndexName : existingEntry?.textSearchIndexName ?? defaultTextSearchIndex;
-			await this.writeRegistryEntry(indexName, {
-				collectionName: targetCollection,
-				searchIndexName: targetSearchIndex,
-				isByo: effectiveIsByo,
-				allowWrites: effectiveWritable,
-				textSearchIndexName,
-				dimension,
-				metric
+			const resolvedAutoEmbed = autoEmbed ? {
+				...autoEmbed,
+				path: autoEmbed.path ?? this.documentFieldName
+			} : void 0;
+			const existingAutoEmbed = existingEntry?.autoEmbed;
+			const embeddingChanged = Boolean(existingAutoEmbed) !== Boolean(resolvedAutoEmbed) || existingAutoEmbed && resolvedAutoEmbed && (existingAutoEmbed.path !== resolvedAutoEmbed.path || existingAutoEmbed.model !== resolvedAutoEmbed.model);
+			if (existingEntry && embeddingChanged) throw new MastraError({
+				id: createVectorErrorId("MONGODB", "CREATE_INDEX", "CONFLICT"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { indexName },
+				text: `Index "${indexName}" is already registered with ${describeEmbedding(existingAutoEmbed)}, but this createIndex call resolves to ${describeEmbedding(resolvedAutoEmbed)}. Call deleteIndex({ indexName: "${indexName}" }) first to rebuild it.`
 			});
+			const registryClaim = {
+				collectionName: targetCollection,
+				...resolvedAutoEmbed ? {
+					"autoEmbed.path": resolvedAutoEmbed.path,
+					"autoEmbed.model": resolvedAutoEmbed.model
+				} : { autoEmbed: null }
+			};
+			try {
+				await this.writeRegistryEntry(indexName, {
+					collectionName: targetCollection,
+					searchIndexName: targetSearchIndex,
+					isByo: effectiveIsByo,
+					allowWrites: effectiveWritable,
+					textSearchIndexName,
+					dimension,
+					...resolvedAutoEmbed ? {} : { metric },
+					autoEmbed: resolvedAutoEmbed
+				}, registryClaim);
+			} catch (error) {
+				if (error?.code !== 11e3) throw error;
+				const winner = await this.readRegistryEntry(indexName);
+				throw new MastraError({
+					id: createVectorErrorId("MONGODB", "CREATE_INDEX", "CONFLICT"),
+					domain: ErrorDomain.STORAGE,
+					category: ErrorCategory.USER,
+					details: { indexName },
+					text: winner ? `Index "${indexName}" was registered concurrently against collection "${winner.collectionName}" with ${describeEmbedding(winner.autoEmbed)}, but this createIndex call resolves to collection "${targetCollection}" with ${describeEmbedding(resolvedAutoEmbed)}. Call deleteIndex({ indexName: "${indexName}" }) first to rebuild it.` : `Index "${indexName}" was registered concurrently by another process and removed again before this call could read it. Retry createIndex.`
+				});
+			}
 			this.indexTargets.set(indexName, {
 				collectionName: targetCollection,
 				searchIndexName: targetSearchIndex,
 				isByo: effectiveIsByo,
 				allowWrites: effectiveWritable,
-				textSearchIndexName
+				textSearchIndexName,
+				autoEmbed: resolvedAutoEmbed
 			});
 			const embeddingField = this.embeddingFieldName;
 			const numDimensions = dimension;
 			const declaredMetadataPaths = this.buildDeclaredMetadataPaths(filterFields);
+			const autoEmbedPath = resolvedAutoEmbed?.path;
+			let searchField;
+			if (autoEmbed) {
+				const { model, path: _path, ...indexOptions } = autoEmbed;
+				searchField = {
+					type: "autoEmbed",
+					modality: "text",
+					path: autoEmbedPath,
+					model,
+					...indexOptions
+				};
+			} else searchField = {
+				type: "vector",
+				path: embeddingField,
+				numDimensions,
+				similarity: mongoMetric
+			};
+			const documentIsEmbedded = autoEmbedPath === this.documentFieldName;
 			const fields = [
-				{
-					type: "vector",
-					path: embeddingField,
-					numDimensions,
-					similarity: mongoMetric
-				},
+				searchField,
 				{
 					type: "filter",
 					path: "_id"
 				},
-				{
+				...documentIsEmbedded ? [] : [{
 					type: "filter",
 					path: this.documentFieldName
-				},
+				}],
 				...declaredMetadataPaths.map((path) => ({
 					type: "filter",
 					path
@@ -499,7 +588,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 				definition: { fields },
 				name: indexNameInternal,
 				type: "vectorSearch"
-			})) this.declaredFilterPaths.set(indexName, /* @__PURE__ */ new Set([this.documentFieldName, ...declaredMetadataPaths]));
+			})) this.declaredFilterPaths.set(indexName, new Set(documentIsEmbedded ? declaredMetadataPaths : [this.documentFieldName, ...declaredMetadataPaths]));
 			if (!effectiveIsByo) await this.createSearchIndexIgnoringExisting(collection, {
 				definition: { mappings: { dynamic: true } },
 				name: textSearchIndexName ?? defaultTextSearchIndex,
@@ -606,7 +695,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	*/
 	async textQuery(params) {
 		const { indexName, query, paths, topK = 10, filter, metadataMode = "field", searchIndexName } = params;
-		const { collectionName } = await this.resolveIndexTarget(indexName);
+		const { collectionName, autoEmbed } = await this.resolveIndexTarget(indexName);
 		const textIndex = searchIndexName ?? await this.resolveTextSearchIndexName(indexName);
 		try {
 			const collection = await this.getCollection(collectionName, true);
@@ -621,7 +710,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 				} },
 				...Object.keys(metadataFilter).length ? [{ $match: metadataFilter }] : [],
 				{ $limit: Math.min(1e4, topK) },
-				...this.buildProjection(metadataMode, false, "searchScore")
+				...this.buildProjection(metadataMode, false, "searchScore", autoEmbed?.path)
 			];
 			return (await collection.aggregate(pipeline).toArray()).map((r) => ({
 				id: this.idToString(r._id),
@@ -644,9 +733,37 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	* need a MongoDB support case to enable, and runs where enabled, e.g. Atlas 8.0.x).
 	*/
 	async hybridQuery(params) {
-		const { indexName, queryVector, query, paths, topK = 10, filter, weights, numCandidates, metadataMode = "field", textSearchIndexName } = params;
+		const { indexName, queryVector, queryText, model, query, paths, topK = 10, filter, weights, numCandidates, metadataMode = "field", textSearchIndexName } = params;
+		if (model && !queryText) throw new MastraError({
+			id: createVectorErrorId("MONGODB", "HYBRID_QUERY", "INVALID_ARGS"),
+			text: "model only applies to queryText, which MongoDB embeds server-side for the vector branch.",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (queryVector && queryText) throw new MastraError({
+			id: createVectorErrorId("MONGODB", "HYBRID_QUERY", "MUTUALLY_EXCLUSIVE"),
+			text: "queryVector and queryText are mutually exclusive: the vector branch takes one or the other.",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!queryVector && !queryText) throw new MastraError({
+			id: createVectorErrorId("MONGODB", "HYBRID_QUERY", "MISSING_VECTOR"),
+			text: "The vector branch needs queryVector (or queryText on an autoEmbed index).",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
 		await this.assertRankFusionSupported();
-		const { collectionName, searchIndexName } = await this.resolveIndexTarget(indexName);
+		const { collectionName, searchIndexName, autoEmbed } = await this.resolveIndexTarget(indexName);
+		if (queryText && !autoEmbed) throw new MastraError({
+			id: createVectorErrorId("MONGODB", "HYBRID_QUERY", "NOT_AUTO_EMBED"),
+			text: `Index "${indexName}" was not created with autoEmbed, so MongoDB cannot embed a query string for it. Pass queryVector instead.`,
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
 		const textIndex = textSearchIndexName ?? await this.resolveTextSearchIndexName(indexName);
 		try {
 			const collection = await this.getCollection(collectionName, true);
@@ -656,8 +773,9 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 			const candidates = Math.min(1e4, Math.max(perBranch, numCandidates ?? topK * 20));
 			const vectorSearch = {
 				index: searchIndexName,
-				path: this.embeddingFieldName,
-				queryVector,
+				path: autoEmbed ? autoEmbed.path : this.embeddingFieldName,
+				...queryText ? { query: { text: queryText } } : { queryVector },
+				...model ? { model } : {},
 				numCandidates: candidates,
 				limit: perBranch
 			};
@@ -699,7 +817,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 					...combination ? { combination } : {}
 				} },
 				{ $limit: Math.min(1e4, topK) },
-				...this.buildProjection(metadataMode, false, "score")
+				...this.buildProjection(metadataMode, false, "score", autoEmbed?.path)
 			];
 			return (await collection.aggregate(pipeline).toArray()).map((r) => ({
 				id: this.idToString(r._id),
@@ -773,17 +891,24 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	* @returns The IDs of the upserted vectors in input order.
 	*/
 	async upsert({ indexName, vectors, metadata, ids, documents }) {
-		validateUpsertInput("MONGODB", vectors, metadata, ids);
-		validateVectorValues("MONGODB", vectors);
+		const { collectionName, autoEmbed } = await this.resolveIndexTarget(indexName);
+		if (autoEmbed) this.validateTextUpsertInput(indexName, documents, vectors, metadata, ids);
+		else {
+			validateUpsertInput("MONGODB", vectors, metadata, ids);
+			validateVectorValues("MONGODB", vectors);
+		}
 		await this.assertWritable(indexName, "UPSERT");
 		if (metadata) this.assertNoCircularReferences(metadata, "UPSERT");
 		try {
-			const { collectionName } = await this.resolveIndexTarget(indexName);
 			const collection = await this.getCollection(collectionName);
-			const stats = await this.describeIndex({ indexName });
-			await this.validateVectorDimensions(vectors, stats.dimension);
-			const generatedIds = ids || vectors.map(() => v4());
-			const operations = vectors.map((vector, idx) => {
+			if (!autoEmbed) {
+				const stats = await this.describeIndex({ indexName });
+				await this.validateVectorDimensions(vectors, stats.dimension);
+			}
+			const rowCount = (autoEmbed ? documents : vectors)?.length ?? 0;
+			const generatedIds = ids || Array.from({ length: rowCount }, () => v4());
+			const operations = Array.from({ length: rowCount }, (_unused, idx) => {
+				const vector = vectors?.[idx];
 				const id = generatedIds[idx];
 				const meta = metadata?.[idx] || {};
 				const doc = documents?.[idx];
@@ -792,10 +917,10 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 					return acc;
 				}, {});
 				const updateDoc = {
-					[this.embeddingFieldName]: vector,
+					...autoEmbed ? {} : { [this.embeddingFieldName]: vector },
 					[this.metadataFieldName]: normalizedMeta
 				};
-				if (doc !== void 0) updateDoc[this.documentFieldName] = doc;
+				if (doc !== void 0) updateDoc[autoEmbed ? autoEmbed.path : this.documentFieldName] = doc;
 				const idMatch = this.buildIdMatch(id);
 				return { updateOne: {
 					filter: { _id: idMatch },
@@ -833,42 +958,78 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	*   recall at the cost of latency. Defaults to 20 * topK, capped at 10000.
 	* @returns Array of results ordered by descending similarity score.
 	*/
-	async query({ indexName, queryVector, topK = 10, filter, includeVector = false, documentFilter, numCandidates, metadataMode = "field" }) {
-		if (!queryVector) throw new MastraError({
+	async query({ indexName, queryVector, queryText, model, topK = 10, filter, includeVector = false, documentFilter, numCandidates, metadataMode = "field" }) {
+		if (model && !queryText) throw new MastraError({
+			id: createVectorErrorId("MONGODB", "QUERY", "INVALID_ARGS"),
+			text: "model only applies to queryText, which MongoDB embeds server-side. A precomputed queryVector has already been embedded.",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (queryVector && queryText) throw new MastraError({
+			id: createVectorErrorId("MONGODB", "QUERY", "MUTUALLY_EXCLUSIVE"),
+			text: "queryVector and queryText are mutually exclusive: pass a vector you embedded yourself, or a string for MongoDB to embed server-side.",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!queryVector && !queryText) throw new MastraError({
 			id: createVectorErrorId("MONGODB", "QUERY", "MISSING_VECTOR"),
-			text: "queryVector is required for MongoDB queries. Metadata-only queries are not supported by this vector store.",
+			text: "queryVector (or queryText on an autoEmbed index) is required for MongoDB queries. Metadata-only queries are not supported by this vector store.",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		const { collectionName, searchIndexName, autoEmbed, isByo } = await this.resolveIndexTarget(indexName);
+		if (queryText && !autoEmbed) throw new MastraError({
+			id: createVectorErrorId("MONGODB", "QUERY", "NOT_AUTO_EMBED"),
+			text: `Index "${indexName}" was not created with autoEmbed, so MongoDB cannot embed a query string for it. Pass queryVector instead, or use textQuery() for full-text search.`,
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (includeVector && autoEmbed) throw new MastraError({
+			id: createVectorErrorId("MONGODB", "QUERY", "INVALID_ARGS"),
+			text: `includeVector is not supported on autoEmbed index "${indexName}": MongoDB keeps the generated embeddings in its own internal database, so they are not on the returned documents.`,
 			domain: ErrorDomain.STORAGE,
 			category: ErrorCategory.USER,
 			details: { indexName }
 		});
 		try {
-			const { collectionName, searchIndexName } = await this.resolveIndexTarget(indexName);
 			const collection = await this.getCollection(collectionName, true);
 			const indexNameInternal = searchIndexName;
 			const metadataFilter = this.transformMetadataFilter(this.transformFilter(filter), metadataMode);
 			const hasMetadataFilter = Object.keys(metadataFilter).length > 0;
 			const vectorSearch = {
 				index: indexNameInternal,
-				queryVector,
-				path: this.embeddingFieldName,
+				...queryText ? { query: { text: queryText } } : { queryVector },
+				...model ? { model } : {},
+				path: autoEmbed ? autoEmbed.path : this.embeddingFieldName,
 				numCandidates: Math.min(1e4, Math.max(topK, numCandidates ?? topK * 20)),
 				limit: Math.min(1e4, topK)
 			};
-			if (hasMetadataFilter) {
-				let declaredPaths;
-				try {
+			const documentTextField = autoEmbed ? autoEmbed.path : this.documentFieldName;
+			const documentFilterExpr = documentFilter ? { [documentTextField]: documentFilter } : void 0;
+			const verifyDocumentPath = Boolean(documentFilterExpr) && !autoEmbed && isByo;
+			if (hasMetadataFilter || documentFilterExpr) {
+				let declaredPaths = /* @__PURE__ */ new Set();
+				if (hasMetadataFilter || verifyDocumentPath) try {
 					declaredPaths = await this.getDeclaredFilterPaths(indexName);
 				} catch {
 					declaredPaths = /* @__PURE__ */ new Set();
 				}
-				if (this.canPushDownFilter(metadataFilter, declaredPaths)) vectorSearch.filter = documentFilter ? { $and: [metadataFilter, { [this.documentFieldName]: documentFilter }] } : metadataFilter;
-				else {
-					const candidateIds = await collection.aggregate([{ $match: metadataFilter }, { $project: { _id: 1 } }]).map((doc) => doc._id).toArray();
+				const pushMetadata = !hasMetadataFilter || this.canPushDownFilter(metadataFilter, declaredPaths);
+				const pushDocument = !documentFilterExpr || !autoEmbed && (!verifyDocumentPath || declaredPaths.has(documentTextField));
+				const pushed = [...hasMetadataFilter && pushMetadata ? [metadataFilter] : [], ...documentFilterExpr && pushDocument ? [documentFilterExpr] : []];
+				if (!pushMetadata || !pushDocument) {
+					const preFilter = [...hasMetadataFilter && !pushMetadata ? [metadataFilter] : [], ...documentFilterExpr && !pushDocument ? [documentFilterExpr] : []];
+					const candidateIds = await collection.aggregate([{ $match: preFilter.length > 1 ? { $and: preFilter } : preFilter[0] }, { $project: { _id: 1 } }]).map((doc) => doc._id).toArray();
 					if (candidateIds.length === 0) return [];
-					vectorSearch.filter = documentFilter ? { $and: [{ _id: { $in: candidateIds } }, { [this.documentFieldName]: documentFilter }] } : { _id: { $in: candidateIds } };
+					pushed.unshift({ _id: { $in: candidateIds } });
 				}
-			} else if (documentFilter) vectorSearch.filter = { [this.documentFieldName]: documentFilter };
-			const pipeline = [{ $vectorSearch: vectorSearch }, ...this.buildProjection(metadataMode, includeVector, "vectorSearchScore")];
+				vectorSearch.filter = pushed.length > 1 ? { $and: pushed } : pushed[0];
+			}
+			const pipeline = [{ $vectorSearch: vectorSearch }, ...this.buildProjection(metadataMode, includeVector, "vectorSearchScore", autoEmbed?.path)];
 			return (await collection.aggregate(pipeline).toArray()).map((result) => ({
 				id: this.idToString(result._id),
 				score: result.score,
@@ -936,10 +1097,11 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	*/
 	async describeIndex({ indexName }) {
 		try {
-			const { collectionName, searchIndexName } = await this.resolveIndexTarget(indexName);
+			const { collectionName, searchIndexName, autoEmbed } = await this.resolveIndexTarget(indexName);
 			const collection = await this.getCollection(collectionName, true);
+			const embeddedFieldName = autoEmbed ? autoEmbed.path : this.embeddingFieldName;
 			const count = await collection.countDocuments({
-				[this.embeddingFieldName]: { $exists: true },
+				[embeddedFieldName]: { $exists: true },
 				_id: { $ne: "__index_metadata__" }
 			});
 			const indexNameInternal = searchIndexName;
@@ -951,7 +1113,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 				details: { indexName },
 				text: `Atlas Search index "${indexNameInternal}" does not exist on collection "${indexName}". The collection may predate Mastra or the index may have been dropped externally.`
 			});
-			const vectorField = indexData.latestDefinition?.fields?.find((f) => f.type === "vector");
+			const vectorField = indexData.latestDefinition?.fields?.find((f) => f.type === "vector" || f.type === "autoEmbed");
 			if (!vectorField) throw new MastraError({
 				id: createVectorErrorId("MONGODB", "DESCRIBE_INDEX", "INVALID"),
 				domain: ErrorDomain.STORAGE,
@@ -960,9 +1122,9 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 				text: `Atlas Search index "${indexNameInternal}" exists but has no vector field. The index may have been created outside of Mastra or without vector configuration.`
 			});
 			return {
-				dimension: vectorField.numDimensions,
+				dimension: vectorField.type === "autoEmbed" ? vectorField.numDimensions ?? 1024 : vectorField.numDimensions,
 				count,
-				metric: {
+				metric: vectorField.type === "autoEmbed" && vectorField.similarity === void 0 ? void 0 : {
 					cosine: "cosine",
 					euclidean: "euclidean",
 					dotProduct: "dotproduct"
@@ -1045,9 +1207,16 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 		if (update.metadata) this.assertNoCircularReferences(update.metadata, "UPDATE_VECTOR");
 		try {
 			if (!update.vector && !update.metadata) throw new Error("No updates provided");
-			const { collectionName } = await this.resolveIndexTarget(indexName);
+			const { collectionName, autoEmbed } = await this.resolveIndexTarget(indexName);
 			const collection = await this.getCollection(collectionName, true);
 			const updateDoc = {};
+			if (update.vector && autoEmbed) throw new MastraError({
+				id: createVectorErrorId("MONGODB", "UPDATE_VECTOR", "INVALID_ARGS"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { indexName },
+				text: `Index "${indexName}" was created with autoEmbed, so MongoDB owns the embeddings and a vector cannot be written directly. Upsert the document with new text instead.`
+			});
 			if (update.vector) {
 				const stats = await this.describeIndex({ indexName });
 				await this.validateVectorDimensions([update.vector], stats.dimension);