feat(MongoDB Atlas Vector Store Node): Add Mongo db vector store Node (#12924)

Co-authored-by: Shireen Missi <94372015+ShireenMissi@users.noreply.github.com>
Co-authored-by: कारतोफ्फेलस्क्रिप्ट™ <netroy@users.noreply.github.com>
Co-authored-by: Shireen Missi <shireen@n8n.io>

Author: 3 people

packages/@n8n/nodes-langchain/nodes/vector_store/VectorStoreMongoDBAtlas/VectorStoreMongoDBAtlas.node.ts

@@ -0,0 +1,266 @@
+import { MongoDBAtlasVectorSearch } from '@langchain/mongodb';
+import { MongoClient } from 'mongodb';
+import { type ILoadOptionsFunctions, NodeOperationError, type INodeProperties } from 'n8n-workflow';
+
+import { metadataFilterField } from '@utils/sharedFields';
+
+import { createVectorStoreNode } from '../shared/createVectorStoreNode/createVectorStoreNode';
+
+const mongoCollectionRLC: INodeProperties = {
+	displayName: 'MongoDB Collection',
+	name: 'mongoCollection',
+	type: 'resourceLocator',
+	default: { mode: 'list', value: '' },
+	required: true,
+	modes: [
+		{
+			displayName: 'From List',
+			name: 'list',
+			type: 'list',
+			typeOptions: {
+				searchListMethod: 'mongoCollectionSearch', // Method to fetch collections
+			},
+		},
+		{
+			displayName: 'Name',
+			name: 'name',
+			type: 'string',
+			placeholder: 'e.g. my_collection',
+		},
+	],
+};
+
+const vectorIndexName: INodeProperties = {
+	displayName: 'Vector Index Name',
+	name: 'vectorIndexName',
+	type: 'string',
+	default: '',
+	description: 'The name of the vector index',
+	required: true,
+};
+
+const embeddingField: INodeProperties = {
+	displayName: 'Embedding',
+	name: 'embedding',
+	type: 'string',
+	default: 'embedding',
+	description: 'The field with the embedding array',
+	required: true,
+};
+
+const metadataField: INodeProperties = {
+	displayName: 'Metadata Field',
+	name: 'metadata_field',
+	type: 'string',
+	default: 'text',
+	description: 'The text field of the raw data',
+	required: true,
+};
+
+const sharedFields: INodeProperties[] = [
+	mongoCollectionRLC,
+	embeddingField,
+	metadataField,
+	vectorIndexName,
+];
+
+const mongoNamespaceField: INodeProperties = {
+	displayName: 'Namespace',
+	name: 'namespace',
+	type: 'string',
+	description: 'Logical partition for documents. Uses metadata.namespace field for filtering.',
+	default: '',
+};
+
+const retrieveFields: INodeProperties[] = [
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add Option',
+		default: {},
+		options: [mongoNamespaceField, metadataFilterField],
+	},
+];
+
+const insertFields: INodeProperties[] = [
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add Option',
+		default: {},
+		options: [
+			{
+				displayName: 'Clear Namespace',
+				name: 'clearNamespace',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to clear documents in the namespace before inserting new data',
+			},
+			mongoNamespaceField,
+		],
+	},
+];
+
+let mongoClient: MongoClient | null = null;
+
+async function getMongoClient(context: any) {
+	if (!mongoClient) {
+		const credentials = await context.getCredentials('mongoDb');
+		mongoClient = new MongoClient(credentials.connectionString as string, {
+			appName: 'devrel.integration.n8n_vector_integ',
+		});
+		await mongoClient.connect();
+	}
+	return mongoClient;
+}
+
+async function mongoClientAndDatabase(context: any) {
+	const client = await getMongoClient(context);
+	const credentials = await context.getCredentials('mongoDb');
+	const db = client.db(credentials.database as string);
+	return { client, db };
+}
+
+async function mongoCollectionSearch(this: ILoadOptionsFunctions) {
+	const { db } = await mongoClientAndDatabase(this);
+	try {
+		const collections = await db.listCollections().toArray();
+		const results = collections.map((collection) => ({
+			name: collection.name,
+			value: collection.name,
+		}));
+
+		return { results };
+	} catch (error) {
+		throw new NodeOperationError(this.getNode(), `Error: ${error.message}`);
+	}
+}
+export class VectorStoreMongoDBAtlas extends createVectorStoreNode({
+	meta: {
+		displayName: 'MongoDB Atlas Vector Store',
+		name: 'vectorStoreMongoDBAtlas',
+		description: 'Work with your data in MongoDB Atlas Vector Store',
+		icon: { light: 'file:mongodb.svg', dark: 'file:mongodb.dark.svg' },
+		docsUrl:
+			'https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.vectorstoremongodbatlas/',
+		credentials: [
+			{
+				name: 'mongoDb',
+				required: true,
+			},
+		],
+		operationModes: ['load', 'insert', 'retrieve', 'update', 'retrieve-as-tool'],
+	},
+	methods: { listSearch: { mongoCollectionSearch } },
+	retrieveFields,
+	loadFields: retrieveFields,
+	insertFields,
+	sharedFields,
+	async getVectorStoreClient(context, _filter, embeddings, itemIndex) {
+		try {
+			const { db } = await mongoClientAndDatabase(context);
+			try {
+				const collectionName = context.getNodeParameter('mongoCollection', itemIndex, '', {
+					extractValue: true,
+				}) as string;
+
+				const mongoVectorIndexName = context.getNodeParameter('vectorIndexName', itemIndex, '', {
+					extractValue: true,
+				}) as string;
+
+				const embeddingFieldName = context.getNodeParameter('embedding', itemIndex, '', {
+					extractValue: true,
+				}) as string;
+
+				const metadataFieldName = context.getNodeParameter('metadata_field', itemIndex, '', {
+					extractValue: true,
+				}) as string;
+
+				const collection = db.collection(collectionName);
+
+				// test index exists
+				const indexes = await collection.listSearchIndexes().toArray();
+
+				const indexExists = indexes.some((index) => index.name === mongoVectorIndexName);
+
+				if (!indexExists) {
+					throw new NodeOperationError(
+						context.getNode(),
+						`Index ${mongoVectorIndexName} not found`,
+						{
+							itemIndex,
+							description: 'Please check that the index exists in your collection',
+						},
+					);
+				}
+
+				return new MongoDBAtlasVectorSearch(embeddings, {
+					collection,
+					indexName: mongoVectorIndexName, // Default index name
+					textKey: metadataFieldName, // Field containing raw text
+					embeddingKey: embeddingFieldName, // Field containing embeddings
+				});
+			} catch (error) {
+				throw new NodeOperationError(context.getNode(), `Error: ${error.message}`, {
+					itemIndex,
+					description: 'Please check your MongoDB Atlas connection details',
+				});
+			} finally {
+				// Don't close the client here to maintain connection pooling
+			}
+		} catch (error) {
+			throw new NodeOperationError(context.getNode(), `Error: ${error.message}`, {
+				itemIndex,
+				description: 'Please check your MongoDB Atlas connection details',
+			});
+		}
+	},
+	async populateVectorStore(context, embeddings, documents, itemIndex) {
+		try {
+			const { db } = await mongoClientAndDatabase(context);
+			try {
+				const mongoCollectionName = context.getNodeParameter('mongoCollection', itemIndex, '', {
+					extractValue: true,
+				}) as string;
+				const embeddingFieldName = context.getNodeParameter('embedding', itemIndex, '', {
+					extractValue: true,
+				}) as string;
+
+				const metadataFieldName = context.getNodeParameter('metadata_field', itemIndex, '', {
+					extractValue: true,
+				}) as string;
+
+				const mongoDBAtlasVectorIndex = context.getNodeParameter('vectorIndexName', itemIndex, '', {
+					extractValue: true,
+				}) as string;
+
+				// Check if collection exists
+				const collections = await db.listCollections({ name: mongoCollectionName }).toArray();
+				if (collections.length === 0) {
+					await db.createCollection(mongoCollectionName);
+				}
+				const collection = db.collection(mongoCollectionName);
+				await MongoDBAtlasVectorSearch.fromDocuments(documents, embeddings, {
+					collection,
+					indexName: mongoDBAtlasVectorIndex, // Default index name
+					textKey: metadataFieldName, // Field containing raw text
+					embeddingKey: embeddingFieldName, // Field containing embeddings
+				});
+			} catch (error) {
+				throw new NodeOperationError(context.getNode(), `Error: ${error.message}`, {
+					itemIndex,
+					description: 'Please check your MongoDB Atlas connection details',
+				});
+			} finally {
+				// Don't close the client here to maintain connection pooling
+			}
+		} catch (error) {
+			throw new NodeOperationError(context.getNode(), `Error: ${error.message}`, {
+				itemIndex,
+				description: 'Please check your MongoDB Atlas connection details',
+			});
+		}
+	},
+}) {}

packages/@n8n/nodes-langchain/nodes/vector_store/VectorStoreMongoDBAtlas/mongodb.dark.svg

@@ -109,6 +109,7 @@
       "dist/nodes/vector_store/VectorStoreInMemory/VectorStoreInMemory.node.js",
       "dist/nodes/vector_store/VectorStoreInMemoryInsert/VectorStoreInMemoryInsert.node.js",
       "dist/nodes/vector_store/VectorStoreInMemoryLoad/VectorStoreInMemoryLoad.node.js",
+      "dist/nodes/vector_store/VectorStoreMongoDBAtlas/VectorStoreMongoDBAtlas.node.js",
       "dist/nodes/vector_store/VectorStorePGVector/VectorStorePGVector.node.js",
       "dist/nodes/vector_store/VectorStorePinecone/VectorStorePinecone.node.js",
       "dist/nodes/vector_store/VectorStorePineconeInsert/VectorStorePineconeInsert.node.js",
@@ -129,8 +130,8 @@
     "@types/json-schema": "^7.0.15",
     "@types/mime-types": "^2.1.0",
     "@types/pg": "^8.11.6",
-    "@types/temp": "^0.9.1",
     "@types/sanitize-html": "^2.11.0",
+    "@types/temp": "^0.9.1",
     "n8n-core": "workspace:*"
   },
   "dependencies": {
@@ -150,6 +151,7 @@
     "@langchain/google-vertexai": "0.1.8",
     "@langchain/groq": "0.1.3",
     "@langchain/mistralai": "0.2.0",
+    "@langchain/mongodb": "^0.1.0",
     "@langchain/ollama": "0.1.4",
     "@langchain/openai": "0.3.17",
     "@langchain/pinecone": "0.1.3",
@@ -178,6 +180,7 @@
     "lodash": "catalog:",
     "mammoth": "1.7.2",
     "mime-types": "2.1.35",
+    "mongodb": "6.11.0",
     "n8n-nodes-base": "workspace:*",
     "n8n-workflow": "workspace:*",
     "openai": "4.78.1",