@mastra/mongodb 1.20.1 → 1.22.0-alpha.0

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-mongodb
 description: Documentation for @mastra/mongodb. Use when working with @mastra/mongodb APIs, configuration, or implementation.
 metadata:
   package: "@mastra/mongodb"
-  version: "1.20.1"
+  version: "1.22.0-alpha.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.20.1",
+  "version": "1.22.0-alpha.0",
   "package": "@mastra/mongodb",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-memory-semantic-recall.md

@@ -20,7 +20,7 @@ After getting a response from the LLM, all new messages (user, assistant, and to
 
 ## Quickstart
 
-Semantic recall is disabled by default. To enable it, set `semanticRecall: true` in `options` and provide a `vector` store and `embedder`:
+Semantic recall is disabled by default. To enable it, set `semanticRecall: true` in `options` and provide a `vector` store and an `embedder`. A store that generates embeddings itself, such as MongoDB with Automated Embedding, works without one. See [Server-side embeddings](#server-side-embeddings).
 
 **LibSQL**:
 
@@ -242,6 +242,40 @@ const options = {
 }
 ```
 
+## Server-side embeddings
+
+Some vector stores generate the embeddings themselves. With one of those, semantic recall runs without an `embedder`: the database embeds each message on write and the search string on arrival. The embedding provider stays out of your application entirely.
+
+MongoDB does this through [Automated Embedding](https://mastra.ai/reference/vectors/mongodb): name a Voyage AI model on the vector store and leave the `embedder` out.
+
+```typescript
+import { Memory } from '@mastra/memory'
+import { MongoDBStore, MongoDBVector } from '@mastra/mongodb'
+
+const memory = new Memory({
+  storage: new MongoDBStore({
+    id: 'agent-storage',
+    uri: process.env.MONGODB_URI,
+    dbName: process.env.MONGODB_DB_NAME,
+  }),
+  vector: new MongoDBVector({
+    id: 'agent-vector',
+    uri: process.env.MONGODB_URI,
+    dbName: process.env.MONGODB_DB_NAME,
+    autoEmbed: { model: 'voyage-4' },
+  }),
+  options: {
+    semanticRecall: { topK: 3, messageRange: 2 },
+  },
+})
+```
+
+Messages are stored as text and MongoDB embeds them, so the model choice and the vector size belong to the index rather than to your application. Recall works the same way through an agent and through [`recall()`](#using-the-recall-method).
+
+MongoDB embeds newly written messages in the background. A message saved moments ago may not be recallable immediately.
+
+Every other store expects your application to supply the vectors, and keeps requiring an `embedder`. Enabling semantic recall with neither an `embedder` nor a store that embeds server-side raises an error naming both options.
+
 ## Embedder configuration
 
 Semantic recall relies on an [embedding model](https://mastra.ai/reference/memory/memory-class) to convert messages into embeddings. Mastra supports embedding models through the model router using `provider/model` strings, or you can use any [embedding model](https://sdk.vercel.ai/docs/ai-sdk-core/embeddings) compatible with the AI SDK.

package/dist/docs/references/docs-storage.md

@@ -194,6 +194,7 @@ Each provider page includes installation instructions, configuration parameters,
 
 - [Aurora DSQL](https://mastra.ai/integrations/databases/aurora-dsql)
 - [ClickHouse](https://mastra.ai/integrations/databases/clickhouse)
+- [ClickHouse Managed Postgres](https://mastra.ai/integrations/databases/clickhouse-managed-postgres)
 - [Cloudflare D1](https://mastra.ai/integrations/databases/cloudflare-d1)
 - [Cloudflare KV](https://mastra.ai/integrations/databases/cloudflare-kv)
 - [Convex](https://mastra.ai/integrations/databases/convex)

package/dist/index.cjs

@@ -9,7 +9,7 @@ let _mastra_core_agent = require("@mastra/core/agent");
 let _mastra_core_evals = require("@mastra/core/evals");
 let _mastra_core_storage_domains_skills = require("@mastra/core/storage/domains/skills");
 //#region package.json
-var version = "1.20.1";
+var version = "1.22.0-alpha.0";
 //#endregion
 //#region src/vector/filter.ts
 /**
@@ -85,11 +85,22 @@ var MongoDBFilterTranslator = class extends _mastra_core_vector_filter.BaseFilte
 function describeEmbedding(config) {
 	return config ? `autoEmbed (path "${config.path}", model "${config.model}")` : "client-side vectors";
 }
+/**
+* Whether Atlas refused a `$vectorSearch` because the index is still in its initial sync. The
+* server reports it as a generic `UnknownError`, so the state named in the message is the only
+* thing that tells it apart from other failures with the same code.
+*/
+function isInitialSyncError(error) {
+	const message = error?.message;
+	return typeof message === "string" && message.includes("while in state INITIAL_SYNC");
+}
 var MongoDBVector = class MongoDBVector extends _mastra_core_vector.MastraVector {
 	client;
 	db;
 	collections;
 	embeddingFieldName;
+	/** Automated Embedding defaults applied to indexes created without their own config. */
+	defaultAutoEmbed;
 	metadataFieldName = "metadata";
 	documentFieldName = "document";
 	/**
@@ -125,6 +136,19 @@ var MongoDBVector = class MongoDBVector extends _mastra_core_vector.MastraVector
 	*/
 	static REGISTRY_COLLECTION = "__mastra_vector_indexes__";
 	/**
+	* Waits between attempts while a queried index is in INITIAL_SYNC, about six seconds in all.
+	* On a live Atlas cluster the window lasted around two seconds for both a regular and an
+	* autoEmbed index; the budget leaves room for a slower build without holding a failing query
+	* for long.
+	*/
+	static INITIAL_SYNC_RETRY_DELAYS_MS = [
+		250,
+		500,
+		1e3,
+		2e3,
+		2e3
+	];
+	/**
 	* MongoDB query operators supported inside `$vectorSearch.filter`. Intentionally
 	* conservative: filters using any operator outside this set fall back to the
 	* `$match` pre-filter, which supports the full query language. Widening this set
@@ -147,7 +171,7 @@ var MongoDBVector = class MongoDBVector extends _mastra_core_vector.MastraVector
 		euclidean: "euclidean",
 		dotproduct: "dotProduct"
 	};
-	constructor({ id, uri, dbName, options, embeddingFieldPath }) {
+	constructor({ id, uri, dbName, options, embeddingFieldPath, autoEmbed }) {
 		super({ id });
 		if (!uri) throw new Error("MongoDBVector requires a connection string. Provide \"uri\" in the constructor options.");
 		const client = new mongodb.MongoClient(uri, {
@@ -161,6 +185,11 @@ var MongoDBVector = class MongoDBVector extends _mastra_core_vector.MastraVector
 		this.db = this.client.db(dbName);
 		this.collections = /* @__PURE__ */ new Map();
 		this.embeddingFieldName = embeddingFieldPath ?? "embedding";
+		this.defaultAutoEmbed = autoEmbed;
+	}
+	/** True once the store is configured with Automated Embedding defaults. */
+	get isSelfEmbedding() {
+		return this.defaultAutoEmbed !== void 0;
 	}
 	/**
 	* Resolve the collection + vector-index names for an index, honoring BYO overrides.
@@ -442,7 +471,8 @@ var MongoDBVector = class MongoDBVector extends _mastra_core_vector.MastraVector
 	* "index not found" or "index not ready" errors on subsequent operations.
 	*/
 	async createIndex(params) {
-		const { indexName, dimension, metric = "cosine", filterFields, collectionName, searchIndexName, allowWrites, autoEmbed } = params;
+		const { indexName, dimension, metric = "cosine", filterFields, collectionName, searchIndexName, allowWrites, autoEmbed: autoEmbedParam } = params;
+		const autoEmbed = autoEmbedParam ?? (dimension === void 0 ? this.defaultAutoEmbed : void 0);
 		let mongoMetric;
 		try {
 			if (autoEmbed) {
@@ -1030,7 +1060,7 @@ var MongoDBVector = class MongoDBVector extends _mastra_core_vector.MastraVector
 				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) => ({
+			return (await this.aggregateVectorSearch(collection, pipeline)).map((result) => ({
 				id: this.idToString(result._id),
 				score: result.score,
 				metadata: result.metadata,
@@ -1047,6 +1077,24 @@ var MongoDBVector = class MongoDBVector extends _mastra_core_vector.MastraVector
 		}
 	}
 	/**
+	* Runs a `$vectorSearch` pipeline, retrying while the index is in INITIAL_SYNC.
+	*
+	* While Atlas first builds a vector search index it usually answers with an empty result, but
+	* for a few seconds it fails with "cannot query vector index ... while in state INITIAL_SYNC"
+	* instead. A caller that creates an index and queries it straight away, as `Memory` does on a
+	* fresh database, can land in that window. Any other error, and an INITIAL_SYNC that outlasts
+	* the retry budget, is thrown unchanged.
+	*/
+	async aggregateVectorSearch(collection, pipeline) {
+		for (const delayMs of MongoDBVector.INITIAL_SYNC_RETRY_DELAYS_MS) try {
+			return await collection.aggregate(pipeline).toArray();
+		} catch (error) {
+			if (!isInitialSyncError(error)) throw error;
+			await new Promise((resolve) => setTimeout(resolve, delayMs));
+		}
+		return collection.aggregate(pipeline).toArray();
+	}
+	/**
 	* Lists LOGICAL Mastra index names, not physical collection names.
 	*
 	* Returns the union of:
@@ -6465,6 +6513,7 @@ const OM_TABLE = "mastra_observational_memory";
 var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_storage.MemoryStorage {
 	supportsPartialThreadUpdate = true;
 	supportsObservationalMemory = true;
+	supportsObservationalMemoryHistorySearch = true;
 	#connector;
 	#skipDefaultIndexes;
 	#indexes;
@@ -6700,8 +6749,11 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			if (!target) continue;
 			const prevMessages = await collection.find({
 				thread_id: target.threadId,
-				createdAt: { $lte: target.createdAt },
-				...resourceFilter
+				...resourceFilter,
+				$or: [{ createdAt: { $lt: target.createdAt } }, {
+					createdAt: target.createdAt,
+					id: { $lte: id }
+				}]
 			}).sort({
 				createdAt: -1,
 				id: -1
@@ -6710,8 +6762,11 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			if (withNextMessages > 0) {
 				const nextMessages = await collection.find({
 					thread_id: target.threadId,
-					createdAt: { $gt: target.createdAt },
-					...resourceFilter
+					...resourceFilter,
+					$or: [{ createdAt: { $gt: target.createdAt } }, {
+						createdAt: target.createdAt,
+						id: { $gt: id }
+					}]
 				}).sort({
 					createdAt: 1,
 					id: 1
@@ -7505,13 +7560,34 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			const lookupKey = this.getOMKey(threadId, resourceId);
 			const collection = await this.getCollection(OM_TABLE);
 			const filter = { lookupKey };
+			if (options?.recordId !== void 0) filter["id"] = options.recordId;
 			if (options?.from || options?.to) {
 				const createdAtFilter = {};
 				if (options.from) createdAtFilter["$gte"] = options.from;
 				if (options.to) createdAtFilter["$lte"] = options.to;
 				filter["createdAt"] = createdAtFilter;
 			}
-			let cursor = collection.find(filter).sort({ generationCount: -1 });
+			if (options?.groupId !== void 0) {
+				const prefix = { $literal: `<observation-group id="${options.groupId}"` };
+				filter["$expr"] = { $or: [{ $gte: [{ $indexOfCP: [{ $ifNull: ["$activeObservations", ""] }, prefix] }, 0] }, { $anyElementTrue: [{ $map: {
+					input: { $cond: [
+						{ $isArray: "$bufferedObservationChunks" },
+						"$bufferedObservationChunks",
+						[]
+					] },
+					as: "chunk",
+					in: { $gte: [{ $indexOfCP: [{ $ifNull: ["$$chunk.observations", ""] }, prefix] }, 0] }
+				} }] }] };
+			}
+			if (options?.beforeGeneration !== void 0 || options?.afterGeneration !== void 0) filter["generationCount"] = {
+				...options.beforeGeneration !== void 0 ? { $lt: options.beforeGeneration } : {},
+				...options.afterGeneration !== void 0 ? { $gt: options.afterGeneration } : {}
+			};
+			let cursor = collection.find(filter).sort({
+				generationCount: options?.sortDirection === "ASC" ? 1 : -1,
+				createdAt: 1,
+				id: 1
+			});
 			if (options?.offset != null) cursor = cursor.skip(options.offset);
 			return (await cursor.limit(limit).toArray()).map((doc) => this.parseOMDocument(doc));
 		} catch (error) {