@mastra/mongodb 0.12.0 → 0.12.1

package/src/storage/types.ts

@@ -0,0 +1,14 @@
+import type { MongoClientOptions } from 'mongodb';
+import type { ConnectorHandler } from './connectors/base';
+
+export type MongoDBConfig =
+  | DatabaseConfig
+  | {
+      connectorHandler: ConnectorHandler;
+    };
+
+export type DatabaseConfig = {
+  url: string;
+  dbName: string;
+  options?: MongoClientOptions;
+};

package/src/vector/index.test.ts

@@ -263,7 +263,10 @@ describe('MongoDBVector Integration Tests', () => {
     beforeAll(async () => {
       // Ensure testIndexName2 has at least one document
       const testVector = [1, 0, 0, 0];
-      const testMetadata = { label: 'test_filter_validation' };
+      const testMetadata = {
+        label: 'test_filter_validation',
+        timestamp: new Date('2024-01-01T00:00:00Z'),
+      };
 
       // First check if there are already documents
       const existingResults = await vectorDB.query({
@@ -338,6 +341,18 @@ describe('MongoDBVector Integration Tests', () => {
       expect(results.length).toBeGreaterThan(0);
     });
 
+    it('handles filters with multiple properties', async () => {
+      const results = await retryQuery({
+        indexName: testIndexName2,
+        queryVector: [1, 0, 0, 0],
+        filter: {
+          'metadata.label': 'test_filter_validation',
+          'metadata.timestamp': { $gt: new Date('2023-01-01T00:00:00Z') },
+        },
+      });
+      expect(results.length).toBeGreaterThan(0);
+    });
+
     it('normalizes date values in filter using filter.ts', async () => {
       const vector = [1, 0, 0, 0];
       const timestampDate = new Date('2024-01-01T00:00:00Z');

package/src/vector/index.ts

@@ -135,8 +135,8 @@ export class MongoDBVector extends MastraVector<MongoDBVectorFilter> {
       const embeddingField = this.embeddingFieldName;
       const numDimensions = dimension;
 
-      // Create the search index
-      await (collection as any).createSearchIndex({
+      // Create search indexes
+      await collection.createSearchIndex({
         definition: {
           fields: [
             {
@@ -145,11 +145,24 @@ export class MongoDBVector extends MastraVector<MongoDBVectorFilter> {
               numDimensions: numDimensions,
               similarity: mongoMetric,
             },
+            {
+              type: 'filter',
+              path: '_id',
+            },
           ],
         },
         name: indexNameInternal,
         type: 'vectorSearch',
       });
+      await collection.createSearchIndex({
+        definition: {
+          mappings: {
+            dynamic: true,
+          },
+        },
+        name: `${indexName}_search_index`,
+        type: 'search',
+      });
     } catch (error: any) {
       if (error.codeName !== 'IndexAlreadyExists') {
         throw new MastraError(
@@ -299,19 +312,29 @@ export class MongoDBVector extends MastraVector<MongoDBVectorFilter> {
         combinedFilter = documentMongoFilter;
       }
 
+      const vectorSearch: Document = {
+        index: indexNameInternal,
+        queryVector: queryVector,
+        path: this.embeddingFieldName,
+        numCandidates: 100,
+        limit: topK,
+      };
+
+      if (Object.keys(combinedFilter).length > 0) {
+        // pre-filter for candidate document IDs
+        const candidateIds = await collection
+          .aggregate([{ $match: combinedFilter }, { $project: { _id: 1 } }])
+          .map(doc => doc._id)
+          .toArray();
+
+        vectorSearch.filter = { _id: { $in: candidateIds } };
+      }
+
       // Build the aggregation pipeline
       const pipeline = [
         {
-          $vectorSearch: {
-            index: indexNameInternal,
-            queryVector: queryVector,
-            path: this.embeddingFieldName,
-            numCandidates: 100,
-            limit: topK,
-          },
+          $vectorSearch: vectorSearch,
         },
-        // Apply the filter using $match stage
-        ...(Object.keys(combinedFilter).length > 0 ? [{ $match: combinedFilter }] : []),
         {
           $set: { score: { $meta: 'vectorSearchScore' } },
         },