@n8n/n8n-nodes-langchain 1.85.2 → 1.86.0

package/dist/nodes/vector_store/VectorStorePGVector/VectorStorePGVector.node.js

@@ -1,248 +1,282 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VectorStorePGVector = void 0;
-const pgvector_1 = require("@langchain/community/vectorstores/pgvector");
-const transport_1 = require("n8n-nodes-base/dist/nodes/Postgres/transport");
-const sharedFields_1 = require("../../../utils/sharedFields");
-const createVectorStoreNode_1 = require("../shared/createVectorStoreNode/createVectorStoreNode");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var VectorStorePGVector_node_exports = {};
+__export(VectorStorePGVector_node_exports, {
+  VectorStorePGVector: () => VectorStorePGVector
+});
+module.exports = __toCommonJS(VectorStorePGVector_node_exports);
+var import_pgvector = require("@langchain/community/vectorstores/pgvector");
+var import_transport = require("n8n-nodes-base/dist/nodes/Postgres/transport/index");
+var import_sharedFields = require("../../../utils/sharedFields");
+var import_createVectorStoreNode = require("../shared/createVectorStoreNode/createVectorStoreNode");
 const sharedFields = [
-    {
-        displayName: 'Table Name',
-        name: 'tableName',
-        type: 'string',
-        default: 'n8n_vectors',
-        description: 'The table name to store the vectors in. If table does not exist, it will be created.',
-    },
+  {
+    displayName: "Table Name",
+    name: "tableName",
+    type: "string",
+    default: "n8n_vectors",
+    description: "The table name to store the vectors in. If table does not exist, it will be created."
+  }
 ];
 const collectionField = {
-    displayName: 'Collection',
-    name: 'collection',
-    type: 'fixedCollection',
-    description: 'Collection of vectors',
-    default: {
-        values: {
-            useCollection: false,
-            collectionName: 'n8n',
-            collectionTable: 'n8n_vector_collections',
+  displayName: "Collection",
+  name: "collection",
+  type: "fixedCollection",
+  description: "Collection of vectors",
+  default: {
+    values: {
+      useCollection: false,
+      collectionName: "n8n",
+      collectionTable: "n8n_vector_collections"
+    }
+  },
+  typeOptions: {},
+  placeholder: "Add Collection Settings",
+  options: [
+    {
+      name: "values",
+      displayName: "Collection Settings",
+      values: [
+        {
+          displayName: "Use Collection",
+          name: "useCollection",
+          type: "boolean",
+          default: false
         },
-    },
-    typeOptions: {},
-    placeholder: 'Add Collection Settings',
-    options: [
         {
-            name: 'values',
-            displayName: 'Collection Settings',
-            values: [
-                {
-                    displayName: 'Use Collection',
-                    name: 'useCollection',
-                    type: 'boolean',
-                    default: false,
-                },
-                {
-                    displayName: 'Collection Name',
-                    name: 'collectionName',
-                    type: 'string',
-                    default: 'n8n',
-                    required: true,
-                    displayOptions: { show: { useCollection: [true] } },
-                },
-                {
-                    displayName: 'Collection Table Name',
-                    name: 'collectionTableName',
-                    type: 'string',
-                    default: 'n8n_vector_collections',
-                    required: true,
-                    displayOptions: { show: { useCollection: [true] } },
-                },
-            ],
+          displayName: "Collection Name",
+          name: "collectionName",
+          type: "string",
+          default: "n8n",
+          required: true,
+          displayOptions: { show: { useCollection: [true] } }
         },
-    ],
+        {
+          displayName: "Collection Table Name",
+          name: "collectionTableName",
+          type: "string",
+          default: "n8n_vector_collections",
+          required: true,
+          displayOptions: { show: { useCollection: [true] } }
+        }
+      ]
+    }
+  ]
 };
 const columnNamesField = {
-    displayName: 'Column Names',
-    name: 'columnNames',
-    type: 'fixedCollection',
-    description: 'The names of the columns in the PGVector table',
-    default: {
-        values: {
-            idColumnName: 'id',
-            vectorColumnName: 'embedding',
-            contentColumnName: 'text',
-            metadataColumnName: 'metadata',
-        },
-    },
-    typeOptions: {},
-    placeholder: 'Set Column Names',
-    options: [
+  displayName: "Column Names",
+  name: "columnNames",
+  type: "fixedCollection",
+  description: "The names of the columns in the PGVector table",
+  default: {
+    values: {
+      idColumnName: "id",
+      vectorColumnName: "embedding",
+      contentColumnName: "text",
+      metadataColumnName: "metadata"
+    }
+  },
+  typeOptions: {},
+  placeholder: "Set Column Names",
+  options: [
+    {
+      name: "values",
+      displayName: "Column Name Settings",
+      values: [
         {
-            name: 'values',
-            displayName: 'Column Name Settings',
-            values: [
-                {
-                    displayName: 'ID Column Name',
-                    name: 'idColumnName',
-                    type: 'string',
-                    default: 'id',
-                    required: true,
-                },
-                {
-                    displayName: 'Vector Column Name',
-                    name: 'vectorColumnName',
-                    type: 'string',
-                    default: 'embedding',
-                    required: true,
-                },
-                {
-                    displayName: 'Content Column Name',
-                    name: 'contentColumnName',
-                    type: 'string',
-                    default: 'text',
-                    required: true,
-                },
-                {
-                    displayName: 'Metadata Column Name',
-                    name: 'metadataColumnName',
-                    type: 'string',
-                    default: 'metadata',
-                    required: true,
-                },
-            ],
+          displayName: "ID Column Name",
+          name: "idColumnName",
+          type: "string",
+          default: "id",
+          required: true
         },
-    ],
-};
-const distanceStrategyField = {
-    displayName: 'Distance Strategy',
-    name: 'distanceStrategy',
-    type: 'options',
-    default: 'cosine',
-    description: 'The method to calculate the distance between two vectors',
-    options: [
         {
-            name: 'Cosine',
-            value: 'cosine',
+          displayName: "Vector Column Name",
+          name: "vectorColumnName",
+          type: "string",
+          default: "embedding",
+          required: true
         },
         {
-            name: 'Inner Product',
-            value: 'innerProduct',
+          displayName: "Content Column Name",
+          name: "contentColumnName",
+          type: "string",
+          default: "text",
+          required: true
         },
         {
-            name: 'Euclidean',
-            value: 'euclidean',
-        },
-    ],
+          displayName: "Metadata Column Name",
+          name: "metadataColumnName",
+          type: "string",
+          default: "metadata",
+          required: true
+        }
+      ]
+    }
+  ]
 };
-const insertFields = [
+const distanceStrategyField = {
+  displayName: "Distance Strategy",
+  name: "distanceStrategy",
+  type: "options",
+  default: "cosine",
+  description: "The method to calculate the distance between two vectors",
+  options: [
     {
-        displayName: 'Options',
-        name: 'options',
-        type: 'collection',
-        placeholder: 'Add Option',
-        default: {},
-        options: [collectionField, columnNamesField],
+      name: "Cosine",
+      value: "cosine"
     },
-];
-const retrieveFields = [
     {
-        displayName: 'Options',
-        name: 'options',
-        type: 'collection',
-        placeholder: 'Add Option',
-        default: {},
-        options: [distanceStrategyField, collectionField, columnNamesField, sharedFields_1.metadataFilterField],
+      name: "Inner Product",
+      value: "innerProduct"
     },
-];
-class ExtendedPGVectorStore extends pgvector_1.PGVectorStore {
-    static async initialize(embeddings, args) {
-        const { dimensions, ...rest } = args;
-        const postgresqlVectorStore = new this(embeddings, rest);
-        await postgresqlVectorStore._initializeClient();
-        await postgresqlVectorStore.ensureTableInDatabase(dimensions);
-        if (postgresqlVectorStore.collectionTableName) {
-            await postgresqlVectorStore.ensureCollectionTableInDatabase();
-        }
-        return postgresqlVectorStore;
+    {
+      name: "Euclidean",
+      value: "euclidean"
     }
-    async similaritySearchVectorWithScore(query, k, filter) {
-        const mergedFilter = { ...this.filter, ...filter };
-        return await super.similaritySearchVectorWithScore(query, k, mergedFilter);
+  ]
+};
+const insertFields = [
+  {
+    displayName: "Options",
+    name: "options",
+    type: "collection",
+    placeholder: "Add Option",
+    default: {},
+    options: [collectionField, columnNamesField]
+  }
+];
+const retrieveFields = [
+  {
+    displayName: "Options",
+    name: "options",
+    type: "collection",
+    placeholder: "Add Option",
+    default: {},
+    options: [distanceStrategyField, collectionField, columnNamesField, import_sharedFields.metadataFilterField]
+  }
+];
+class ExtendedPGVectorStore extends import_pgvector.PGVectorStore {
+  static async initialize(embeddings, args) {
+    const { dimensions, ...rest } = args;
+    const postgresqlVectorStore = new this(embeddings, rest);
+    await postgresqlVectorStore._initializeClient();
+    await postgresqlVectorStore.ensureTableInDatabase(dimensions);
+    if (postgresqlVectorStore.collectionTableName) {
+      await postgresqlVectorStore.ensureCollectionTableInDatabase();
     }
+    return postgresqlVectorStore;
+  }
+  async similaritySearchVectorWithScore(query, k, filter) {
+    const mergedFilter = { ...this.filter, ...filter };
+    return await super.similaritySearchVectorWithScore(query, k, mergedFilter);
+  }
 }
-class VectorStorePGVector extends (0, createVectorStoreNode_1.createVectorStoreNode)({
-    meta: {
-        description: 'Work with your data in Postgresql with the PGVector extension',
-        icon: 'file:postgres.svg',
-        displayName: 'Postgres PGVector Store',
-        docsUrl: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.vectorstorepgvector/',
-        name: 'vectorStorePGVector',
-        credentials: [
-            {
-                name: 'postgres',
-                required: true,
-                testedBy: 'postgresConnectionTest',
-            },
-        ],
-        operationModes: ['load', 'insert', 'retrieve', 'retrieve-as-tool'],
-    },
-    sharedFields,
-    insertFields,
-    loadFields: retrieveFields,
-    retrieveFields,
-    async getVectorStoreClient(context, filter, embeddings, itemIndex) {
-        const tableName = context.getNodeParameter('tableName', itemIndex, '', {
-            extractValue: true,
-        });
-        const credentials = await context.getCredentials('postgres');
-        const pgConf = await transport_1.configurePostgres.call(context, credentials);
-        const pool = pgConf.db.$pool;
-        const config = {
-            pool,
-            tableName,
-            filter,
-        };
-        const collectionOptions = context.getNodeParameter('options.collection.values', 0, {});
-        if (collectionOptions && collectionOptions.useCollection) {
-            config.collectionName = collectionOptions.collectionName;
-            config.collectionTableName = collectionOptions.collectionTableName;
-        }
-        config.columns = context.getNodeParameter('options.columnNames.values', 0, {
-            idColumnName: 'id',
-            vectorColumnName: 'embedding',
-            contentColumnName: 'text',
-            metadataColumnName: 'metadata',
-        });
-        config.distanceStrategy = context.getNodeParameter('options.distanceStrategy', 0, 'cosine');
-        return await ExtendedPGVectorStore.initialize(embeddings, config);
-    },
-    async populateVectorStore(context, embeddings, documents, itemIndex) {
-        const tableName = context.getNodeParameter('tableName', itemIndex, '', {
-            extractValue: true,
-        });
-        const credentials = await context.getCredentials('postgres');
-        const pgConf = await transport_1.configurePostgres.call(context, credentials);
-        const pool = pgConf.db.$pool;
-        const config = {
-            pool,
-            tableName,
-        };
-        const collectionOptions = context.getNodeParameter('options.collection.values', 0, {});
-        if (collectionOptions && collectionOptions.useCollection) {
-            config.collectionName = collectionOptions.collectionName;
-            config.collectionTableName = collectionOptions.collectionTableName;
-        }
-        config.columns = context.getNodeParameter('options.columnNames.values', 0, {
-            idColumnName: 'id',
-            vectorColumnName: 'embedding',
-            contentColumnName: 'text',
-            metadataColumnName: 'metadata',
-        });
-        const vectorStore = await pgvector_1.PGVectorStore.fromDocuments(documents, embeddings, config);
-        vectorStore.client?.release();
-    },
-    releaseVectorStoreClient(vectorStore) {
-        vectorStore.client?.release();
-    },
+class VectorStorePGVector extends (0, import_createVectorStoreNode.createVectorStoreNode)({
+  meta: {
+    description: "Work with your data in Postgresql with the PGVector extension",
+    icon: "file:postgres.svg",
+    displayName: "Postgres PGVector Store",
+    docsUrl: "https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.vectorstorepgvector/",
+    name: "vectorStorePGVector",
+    credentials: [
+      {
+        name: "postgres",
+        required: true,
+        testedBy: "postgresConnectionTest"
+      }
+    ],
+    operationModes: ["load", "insert", "retrieve", "retrieve-as-tool"]
+  },
+  sharedFields,
+  insertFields,
+  loadFields: retrieveFields,
+  retrieveFields,
+  async getVectorStoreClient(context, filter, embeddings, itemIndex) {
+    const tableName = context.getNodeParameter("tableName", itemIndex, "", {
+      extractValue: true
+    });
+    const credentials = await context.getCredentials("postgres");
+    const pgConf = await import_transport.configurePostgres.call(context, credentials);
+    const pool = pgConf.db.$pool;
+    const config = {
+      pool,
+      tableName,
+      filter
+    };
+    const collectionOptions = context.getNodeParameter(
+      "options.collection.values",
+      0,
+      {}
+    );
+    if (collectionOptions && collectionOptions.useCollection) {
+      config.collectionName = collectionOptions.collectionName;
+      config.collectionTableName = collectionOptions.collectionTableName;
+    }
+    config.columns = context.getNodeParameter("options.columnNames.values", 0, {
+      idColumnName: "id",
+      vectorColumnName: "embedding",
+      contentColumnName: "text",
+      metadataColumnName: "metadata"
+    });
+    config.distanceStrategy = context.getNodeParameter(
+      "options.distanceStrategy",
+      0,
+      "cosine"
+    );
+    return await ExtendedPGVectorStore.initialize(embeddings, config);
+  },
+  async populateVectorStore(context, embeddings, documents, itemIndex) {
+    const tableName = context.getNodeParameter("tableName", itemIndex, "", {
+      extractValue: true
+    });
+    const credentials = await context.getCredentials("postgres");
+    const pgConf = await import_transport.configurePostgres.call(context, credentials);
+    const pool = pgConf.db.$pool;
+    const config = {
+      pool,
+      tableName
+    };
+    const collectionOptions = context.getNodeParameter(
+      "options.collection.values",
+      0,
+      {}
+    );
+    if (collectionOptions && collectionOptions.useCollection) {
+      config.collectionName = collectionOptions.collectionName;
+      config.collectionTableName = collectionOptions.collectionTableName;
+    }
+    config.columns = context.getNodeParameter("options.columnNames.values", 0, {
+      idColumnName: "id",
+      vectorColumnName: "embedding",
+      contentColumnName: "text",
+      metadataColumnName: "metadata"
+    });
+    const vectorStore = await import_pgvector.PGVectorStore.fromDocuments(documents, embeddings, config);
+    vectorStore.client?.release();
+  },
+  releaseVectorStoreClient(vectorStore) {
+    vectorStore.client?.release();
+  }
 }) {
 }
-exports.VectorStorePGVector = VectorStorePGVector;
-//# sourceMappingURL=VectorStorePGVector.node.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VectorStorePGVector
+});