langchain 0.0.127 → 0.0.128

package/dist/retrievers/self_query/weaviate.cjs

@@ -3,6 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WeaviateTranslator = void 0;
 const ir_js_1 = require("../../chains/query_constructor/ir.cjs");
 const base_js_1 = require("./base.cjs");
+const utils_js_1 = require("./utils.cjs");
+function isInt(value) {
+    const numberValue = parseFloat(value);
+    return !Number.isNaN(numberValue) && numberValue % 1 === 0;
+}
+function isFloat(value) {
+    const numberValue = parseFloat(value);
+    return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
+}
+function isString(value) {
+    return typeof value === "string" && Number.isNaN(parseFloat(value));
+}
 class WeaviateTranslator extends base_js_1.BaseTranslator {
     constructor() {
         super(...arguments);
@@ -62,28 +74,26 @@ class WeaviateTranslator extends base_js_1.BaseTranslator {
         };
     }
     visitComparison(comparison) {
-        if (typeof comparison.value === "string") {
+        if (isString(comparison.value)) {
             return {
                 path: [comparison.attribute],
                 operator: this.formatFunction(comparison.comparator),
                 valueText: comparison.value,
             };
         }
-        if (typeof comparison.value === "number") {
-            if (Number.isInteger(comparison.value)) {
-                return {
-                    path: [comparison.attribute],
-                    operator: this.formatFunction(comparison.comparator),
-                    valueInt: comparison.value,
-                };
-            }
-            else {
-                return {
-                    path: [comparison.attribute],
-                    operator: this.formatFunction(comparison.comparator),
-                    valueNumber: comparison.value,
-                };
-            }
+        if (isInt(comparison.value)) {
+            return {
+                path: [comparison.attribute],
+                operator: this.formatFunction(comparison.comparator),
+                valueInt: parseInt(comparison.value, 10),
+            };
+        }
+        if (isFloat(comparison.value)) {
+            return {
+                path: [comparison.attribute],
+                operator: this.formatFunction(comparison.comparator),
+                valueNumber: parseFloat(comparison.value),
+            };
         }
         throw new Error("Value type is not supported");
     }
@@ -96,5 +106,46 @@ class WeaviateTranslator extends base_js_1.BaseTranslator {
         }
         return nextArg;
     }
+    mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
+        if ((0, utils_js_1.isFilterEmpty)(defaultFilter?.where) &&
+            (0, utils_js_1.isFilterEmpty)(generatedFilter?.where)) {
+            return undefined;
+        }
+        if ((0, utils_js_1.isFilterEmpty)(defaultFilter?.where) || mergeType === "replace") {
+            if ((0, utils_js_1.isFilterEmpty)(generatedFilter?.where)) {
+                return undefined;
+            }
+            return generatedFilter;
+        }
+        if ((0, utils_js_1.isFilterEmpty)(generatedFilter?.where)) {
+            if (mergeType === "and") {
+                return undefined;
+            }
+            return defaultFilter;
+        }
+        const merged = {
+            operator: "And",
+            operands: [
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                defaultFilter.where,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                generatedFilter.where,
+            ],
+        };
+        if (mergeType === "and") {
+            return {
+                where: merged,
+            };
+        }
+        else if (mergeType === "or") {
+            merged.operator = "Or";
+            return {
+                where: merged,
+            };
+        }
+        else {
+            throw new Error("Unknown merge type");
+        }
+    }
 }
 exports.WeaviateTranslator = WeaviateTranslator;

package/dist/retrievers/self_query/weaviate.d.ts

@@ -1,4 +1,5 @@
 import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "../../chains/query_constructor/ir.js";
+import { WeaviateFilter, WeaviateStore } from "../../vectorstores/weaviate.js";
 import { BaseTranslator } from "./base.js";
 type WeaviateOperatorValues = {
     valueText: string;
@@ -24,17 +25,19 @@ export type WeaviateComparisonResult = {
     operator: string;
 } & ExclusiveOperatorValue;
 export type WeaviateStructuredQueryResult = {
-    filter?: WeaviateComparisonResult | WeaviateOperationResult | WeaviateStructuredQueryResult;
+    filter?: {
+        where?: WeaviateComparisonResult | WeaviateOperationResult;
+    };
 };
-export declare class WeaviateTranslator extends BaseTranslator {
+export declare class WeaviateTranslator<T extends WeaviateStore> extends BaseTranslator<T> {
     VisitOperationOutput: WeaviateOperationResult;
     VisitComparisonOutput: WeaviateComparisonResult;
-    VisitStructuredQueryOutput: WeaviateStructuredQueryResult;
     allowedOperators: Operator[];
     allowedComparators: Comparator[];
     formatFunction(func: Operator | Comparator): string;
     visitOperation(operation: Operation): this["VisitOperationOutput"];
     visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
     visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
+    mergeFilters(defaultFilter: WeaviateFilter | undefined, generatedFilter: WeaviateFilter | undefined, mergeType?: string): WeaviateFilter | undefined;
 }
 export {};

package/dist/retrievers/self_query/weaviate.js

@@ -1,5 +1,17 @@
 import { Comparators, Operators, } from "../../chains/query_constructor/ir.js";
 import { BaseTranslator } from "./base.js";
+import { isFilterEmpty } from "./utils.js";
+function isInt(value) {
+    const numberValue = parseFloat(value);
+    return !Number.isNaN(numberValue) && numberValue % 1 === 0;
+}
+function isFloat(value) {
+    const numberValue = parseFloat(value);
+    return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
+}
+function isString(value) {
+    return typeof value === "string" && Number.isNaN(parseFloat(value));
+}
 export class WeaviateTranslator extends BaseTranslator {
     constructor() {
         super(...arguments);
@@ -59,28 +71,26 @@ export class WeaviateTranslator extends BaseTranslator {
         };
     }
     visitComparison(comparison) {
-        if (typeof comparison.value === "string") {
+        if (isString(comparison.value)) {
             return {
                 path: [comparison.attribute],
                 operator: this.formatFunction(comparison.comparator),
                 valueText: comparison.value,
             };
         }
-        if (typeof comparison.value === "number") {
-            if (Number.isInteger(comparison.value)) {
-                return {
-                    path: [comparison.attribute],
-                    operator: this.formatFunction(comparison.comparator),
-                    valueInt: comparison.value,
-                };
-            }
-            else {
-                return {
-                    path: [comparison.attribute],
-                    operator: this.formatFunction(comparison.comparator),
-                    valueNumber: comparison.value,
-                };
-            }
+        if (isInt(comparison.value)) {
+            return {
+                path: [comparison.attribute],
+                operator: this.formatFunction(comparison.comparator),
+                valueInt: parseInt(comparison.value, 10),
+            };
+        }
+        if (isFloat(comparison.value)) {
+            return {
+                path: [comparison.attribute],
+                operator: this.formatFunction(comparison.comparator),
+                valueNumber: parseFloat(comparison.value),
+            };
         }
         throw new Error("Value type is not supported");
     }
@@ -93,4 +103,45 @@ export class WeaviateTranslator extends BaseTranslator {
         }
         return nextArg;
     }
+    mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
+        if (isFilterEmpty(defaultFilter?.where) &&
+            isFilterEmpty(generatedFilter?.where)) {
+            return undefined;
+        }
+        if (isFilterEmpty(defaultFilter?.where) || mergeType === "replace") {
+            if (isFilterEmpty(generatedFilter?.where)) {
+                return undefined;
+            }
+            return generatedFilter;
+        }
+        if (isFilterEmpty(generatedFilter?.where)) {
+            if (mergeType === "and") {
+                return undefined;
+            }
+            return defaultFilter;
+        }
+        const merged = {
+            operator: "And",
+            operands: [
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                defaultFilter.where,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                generatedFilter.where,
+            ],
+        };
+        if (mergeType === "and") {
+            return {
+                where: merged,
+            };
+        }
+        else if (mergeType === "or") {
+            merged.operator = "Or";
+            return {
+                where: merged,
+            };
+        }
+        else {
+            throw new Error("Unknown merge type");
+        }
+    }
 }

package/dist/types/openai-types.d.ts

@@ -19,6 +19,8 @@ export declare interface OpenAIBaseInput {
     n: number;
     /** Dictionary used to adjust the probability of specific tokens being generated */
     logitBias?: Record<string, number>;
+    /** Unique string identifier representing your end-user, which can help OpenAI to monitor and detect abuse. */
+    user?: string;
     /** Whether to stream the results or not. Enabling disables tokenUsage reporting */
     streaming: boolean;
     /** Model name to use */

package/dist/util/event-source-parse.cjs

@@ -1,13 +1,10 @@
 "use strict";
-/* eslint-disable prefer-template */
-/* eslint-disable default-case */
-/* eslint-disable no-plusplus */
-// Adapted from https://github.com/gfortaine/fetch-event-source/blob/main/src/parse.ts
-// due to a packaging issue in the original.
-// MIT License
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMessages = exports.getLines = exports.getBytes = exports.EventStreamContentType = void 0;
 exports.EventStreamContentType = "text/event-stream";
+function isNodeJSReadable(x) {
+    return x != null && typeof x === "object" && "on" in x;
+}
 /**
  * Converts a ReadableStream into a callback pattern.
  * @param stream The input ReadableStream.
@@ -15,6 +12,25 @@ exports.EventStreamContentType = "text/event-stream";
  * @returns {Promise<void>} A promise that will be resolved when the stream closes.
  */
 async function getBytes(stream, onChunk) {
+    // stream is a Node.js Readable / PassThrough stream
+    // this can happen if node-fetch is polyfilled
+    if (isNodeJSReadable(stream)) {
+        return new Promise((resolve) => {
+            stream.on("readable", () => {
+                let chunk;
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    chunk = stream.read();
+                    if (chunk == null) {
+                        onChunk(new Uint8Array(), true);
+                        break;
+                    }
+                    onChunk(chunk);
+                }
+                resolve();
+            });
+        });
+    }
     const reader = stream.getReader();
     // CHANGED: Introduced a "flush" mechanism to process potential pending messages when the stream ends.
     //          This change is essential to ensure that we capture every last piece of information from streams,

package/dist/util/event-source-parse.js

@@ -1,10 +1,7 @@
-/* eslint-disable prefer-template */
-/* eslint-disable default-case */
-/* eslint-disable no-plusplus */
-// Adapted from https://github.com/gfortaine/fetch-event-source/blob/main/src/parse.ts
-// due to a packaging issue in the original.
-// MIT License
 export const EventStreamContentType = "text/event-stream";
+function isNodeJSReadable(x) {
+    return x != null && typeof x === "object" && "on" in x;
+}
 /**
  * Converts a ReadableStream into a callback pattern.
  * @param stream The input ReadableStream.
@@ -12,6 +9,25 @@ export const EventStreamContentType = "text/event-stream";
  * @returns {Promise<void>} A promise that will be resolved when the stream closes.
  */
 export async function getBytes(stream, onChunk) {
+    // stream is a Node.js Readable / PassThrough stream
+    // this can happen if node-fetch is polyfilled
+    if (isNodeJSReadable(stream)) {
+        return new Promise((resolve) => {
+            stream.on("readable", () => {
+                let chunk;
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    chunk = stream.read();
+                    if (chunk == null) {
+                        onChunk(new Uint8Array(), true);
+                        break;
+                    }
+                    onChunk(chunk);
+                }
+                resolve();
+            });
+        });
+    }
     const reader = stream.getReader();
     // CHANGED: Introduced a "flush" mechanism to process potential pending messages when the stream ends.
     //          This change is essential to ensure that we capture every last piece of information from streams,

package/dist/util/ollama.cjs

@@ -3,7 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOllamaStream = void 0;
 const stream_js_1 = require("./stream.cjs");
 async function* createOllamaStream(baseUrl, params, options) {
-    const response = await fetch(`${baseUrl}/api/generate`, {
+    let formattedBaseUrl = baseUrl;
+    if (formattedBaseUrl.startsWith("http://localhost:")) {
+        // Node 18 has issues with resolving "localhost"
+        // See https://github.com/node-fetch/node-fetch/issues/1624
+        formattedBaseUrl = formattedBaseUrl.replace("http://localhost:", "http://127.0.0.1:");
+    }
+    const response = await fetch(`${formattedBaseUrl}/api/generate`, {
         method: "POST",
         body: JSON.stringify(params),
         headers: {
@@ -25,7 +31,15 @@ async function* createOllamaStream(baseUrl, params, options) {
     const decoder = new TextDecoder();
     for await (const chunk of stream) {
         try {
-            yield JSON.parse(decoder.decode(chunk));
+            if (chunk !== undefined) {
+                const lines = decoder
+                    .decode(chunk)
+                    .split("\n")
+                    .filter((v) => v.length);
+                for (const line of lines) {
+                    yield JSON.parse(line);
+                }
+            }
         }
         catch (e) {
             console.warn(`Received a non-JSON parseable chunk: ${decoder.decode(chunk)}`);

package/dist/util/ollama.js

@@ -1,6 +1,12 @@
 import { IterableReadableStream } from "./stream.js";
 export async function* createOllamaStream(baseUrl, params, options) {
-    const response = await fetch(`${baseUrl}/api/generate`, {
+    let formattedBaseUrl = baseUrl;
+    if (formattedBaseUrl.startsWith("http://localhost:")) {
+        // Node 18 has issues with resolving "localhost"
+        // See https://github.com/node-fetch/node-fetch/issues/1624
+        formattedBaseUrl = formattedBaseUrl.replace("http://localhost:", "http://127.0.0.1:");
+    }
+    const response = await fetch(`${formattedBaseUrl}/api/generate`, {
         method: "POST",
         body: JSON.stringify(params),
         headers: {
@@ -22,7 +28,15 @@ export async function* createOllamaStream(baseUrl, params, options) {
     const decoder = new TextDecoder();
     for await (const chunk of stream) {
         try {
-            yield JSON.parse(decoder.decode(chunk));
+            if (chunk !== undefined) {
+                const lines = decoder
+                    .decode(chunk)
+                    .split("\n")
+                    .filter((v) => v.length);
+                for (const line of lines) {
+                    yield JSON.parse(line);
+                }
+            }
         }
         catch (e) {
             console.warn(`Received a non-JSON parseable chunk: ${decoder.decode(chunk)}`);

package/dist/util/sql_utils.cjs

@@ -107,6 +107,25 @@ const getTableAndColumnsName = async (appDataSource) => {
         const rep = await appDataSource.query(sql);
         return formatToSqlTable(rep);
     }
+    if (appDataSource.options.type === "sap") {
+        const schema = appDataSource.options?.schema ?? "public";
+        sql = `SELECT
+        TABLE_NAME,
+        COLUMN_NAME,
+        DATA_TYPE_NAME AS data_type,
+        CASE WHEN IS_NULLABLE='TRUE' THEN 'YES' ELSE 'NO' END AS is_nullable
+      FROM TABLE_COLUMNS
+      WHERE SCHEMA_NAME='${schema}'`;
+        const rep = await appDataSource.query(sql);
+        const repLowerCase = [];
+        rep.forEach((_rep) => repLowerCase.push({
+            table_name: _rep.TABLE_NAME,
+            column_name: _rep.COLUMN_NAME,
+            data_type: _rep.DATA_TYPE,
+            is_nullable: _rep.IS_NULLABLE,
+        }));
+        return formatToSqlTable(repLowerCase);
+    }
     throw new Error("Database type not implemented yet");
 };
 exports.getTableAndColumnsName = getTableAndColumnsName;
@@ -127,9 +146,16 @@ const generateTableInfoFromTables = async (tables, appDataSource, nbSampleRow) =
     let globalString = "";
     for (const currentTable of tables) {
         // Add the creation of the table in SQL
-        const schema = appDataSource.options.type === "postgres"
-            ? appDataSource.options?.schema ?? "public"
-            : null;
+        let schema = null;
+        if (appDataSource.options.type === "postgres") {
+            schema = appDataSource.options?.schema ?? "public";
+        }
+        else if (appDataSource.options.type === "sap") {
+            schema =
+                appDataSource.options?.schema ??
+                    appDataSource.options?.username ??
+                    "public";
+        }
         let sqlCreateTableQuery = schema
             ? `CREATE TABLE "${schema}"."${currentTable.tableName}" (\n`
             : `CREATE TABLE ${currentTable.tableName} (\n`;
@@ -152,6 +178,12 @@ const generateTableInfoFromTables = async (tables, appDataSource, nbSampleRow) =
         else if (appDataSource.options.type === "mssql") {
             sqlSelectInfoQuery = `SELECT TOP ${nbSampleRow} * FROM [${currentTable.tableName}];\n`;
         }
+        else if (appDataSource.options.type === "sap") {
+            const schema = appDataSource.options?.schema ??
+                appDataSource.options?.username ??
+                "public";
+            sqlSelectInfoQuery = `SELECT * FROM "${schema}"."${currentTable.tableName}" LIMIT ${nbSampleRow};\n`;
+        }
         else {
             sqlSelectInfoQuery = `SELECT * FROM "${currentTable.tableName}" LIMIT ${nbSampleRow};\n`;
         }
@@ -188,6 +220,9 @@ const getPromptTemplateFromDataSource = (appDataSource) => {
     if (appDataSource.options.type === "mssql") {
         return sql_db_prompt_js_1.SQL_MSSQL_PROMPT;
     }
+    if (appDataSource.options.type === "sap") {
+        return sql_db_prompt_js_1.SQL_SAP_HANA_PROMPT;
+    }
     return sql_db_prompt_js_1.DEFAULT_SQL_DATABASE_PROMPT;
 };
 exports.getPromptTemplateFromDataSource = getPromptTemplateFromDataSource;

package/dist/util/sql_utils.js

@@ -1,4 +1,4 @@
-import { DEFAULT_SQL_DATABASE_PROMPT, SQL_MSSQL_PROMPT, SQL_MYSQL_PROMPT, SQL_POSTGRES_PROMPT, SQL_SQLITE_PROMPT, } from "../chains/sql_db/sql_db_prompt.js";
+import { DEFAULT_SQL_DATABASE_PROMPT, SQL_SAP_HANA_PROMPT, SQL_MSSQL_PROMPT, SQL_MYSQL_PROMPT, SQL_POSTGRES_PROMPT, SQL_SQLITE_PROMPT, } from "../chains/sql_db/sql_db_prompt.js";
 export const verifyListTablesExistInDatabase = (tablesFromDatabase, listTables, errorPrefixMsg) => {
     const onlyTableNames = tablesFromDatabase.map((table) => table.tableName);
     if (listTables.length > 0) {
@@ -101,6 +101,25 @@ export const getTableAndColumnsName = async (appDataSource) => {
         const rep = await appDataSource.query(sql);
         return formatToSqlTable(rep);
     }
+    if (appDataSource.options.type === "sap") {
+        const schema = appDataSource.options?.schema ?? "public";
+        sql = `SELECT
+        TABLE_NAME,
+        COLUMN_NAME,
+        DATA_TYPE_NAME AS data_type,
+        CASE WHEN IS_NULLABLE='TRUE' THEN 'YES' ELSE 'NO' END AS is_nullable
+      FROM TABLE_COLUMNS
+      WHERE SCHEMA_NAME='${schema}'`;
+        const rep = await appDataSource.query(sql);
+        const repLowerCase = [];
+        rep.forEach((_rep) => repLowerCase.push({
+            table_name: _rep.TABLE_NAME,
+            column_name: _rep.COLUMN_NAME,
+            data_type: _rep.DATA_TYPE,
+            is_nullable: _rep.IS_NULLABLE,
+        }));
+        return formatToSqlTable(repLowerCase);
+    }
     throw new Error("Database type not implemented yet");
 };
 const formatSqlResponseToSimpleTableString = (rawResult) => {
@@ -120,9 +139,16 @@ export const generateTableInfoFromTables = async (tables, appDataSource, nbSampl
     let globalString = "";
     for (const currentTable of tables) {
         // Add the creation of the table in SQL
-        const schema = appDataSource.options.type === "postgres"
-            ? appDataSource.options?.schema ?? "public"
-            : null;
+        let schema = null;
+        if (appDataSource.options.type === "postgres") {
+            schema = appDataSource.options?.schema ?? "public";
+        }
+        else if (appDataSource.options.type === "sap") {
+            schema =
+                appDataSource.options?.schema ??
+                    appDataSource.options?.username ??
+                    "public";
+        }
         let sqlCreateTableQuery = schema
             ? `CREATE TABLE "${schema}"."${currentTable.tableName}" (\n`
             : `CREATE TABLE ${currentTable.tableName} (\n`;
@@ -145,6 +171,12 @@ export const generateTableInfoFromTables = async (tables, appDataSource, nbSampl
         else if (appDataSource.options.type === "mssql") {
             sqlSelectInfoQuery = `SELECT TOP ${nbSampleRow} * FROM [${currentTable.tableName}];\n`;
         }
+        else if (appDataSource.options.type === "sap") {
+            const schema = appDataSource.options?.schema ??
+                appDataSource.options?.username ??
+                "public";
+            sqlSelectInfoQuery = `SELECT * FROM "${schema}"."${currentTable.tableName}" LIMIT ${nbSampleRow};\n`;
+        }
         else {
             sqlSelectInfoQuery = `SELECT * FROM "${currentTable.tableName}" LIMIT ${nbSampleRow};\n`;
         }
@@ -180,5 +212,8 @@ export const getPromptTemplateFromDataSource = (appDataSource) => {
     if (appDataSource.options.type === "mssql") {
         return SQL_MSSQL_PROMPT;
     }
+    if (appDataSource.options.type === "sap") {
+        return SQL_SAP_HANA_PROMPT;
+    }
     return DEFAULT_SQL_DATABASE_PROMPT;
 };

package/dist/vectorstores/chroma.cjs

@@ -180,15 +180,14 @@ class Chroma extends base_js_1.VectorStore {
         const [firstMetadatas] = metadatas;
         const results = [];
         for (let i = 0; i < firstIds.length; i += 1) {
-            let metadata = {};
-            const storedMetadata = firstMetadatas?.[i];
-            if (storedMetadata && storedMetadata.locFrom && storedMetadata.locTo) {
+            let metadata = firstMetadatas?.[i] ?? {};
+            if (metadata.locFrom && metadata.locTo) {
                 metadata = {
-                    ...firstMetadatas[i],
+                    ...metadata,
                     loc: {
                         lines: {
-                            from: storedMetadata.locFrom,
-                            to: storedMetadata.locTo,
+                            from: metadata.locFrom,
+                            to: metadata.locTo,
                         },
                     },
                 };

package/dist/vectorstores/chroma.js

@@ -154,15 +154,14 @@ export class Chroma extends VectorStore {
         const [firstMetadatas] = metadatas;
         const results = [];
         for (let i = 0; i < firstIds.length; i += 1) {
-            let metadata = {};
-            const storedMetadata = firstMetadatas?.[i];
-            if (storedMetadata && storedMetadata.locFrom && storedMetadata.locTo) {
+            let metadata = firstMetadatas?.[i] ?? {};
+            if (metadata.locFrom && metadata.locTo) {
                 metadata = {
-                    ...firstMetadatas[i],
+                    ...metadata,
                     loc: {
                         lines: {
-                            from: storedMetadata.locFrom,
-                            to: storedMetadata.locTo,
+                            from: metadata.locFrom,
+                            to: metadata.locTo,
                         },
                     },
                 };

package/dist/vectorstores/faiss.cjs

@@ -32,6 +32,12 @@ class FaissStore extends base_js_1.SaveableVectorStore {
     _vectorstoreType() {
         return "faiss";
     }
+    getMapping() {
+        return this._mapping;
+    }
+    getDocstore() {
+        return this.docstore;
+    }
     constructor(embeddings, args) {
         super(embeddings, args);
         Object.defineProperty(this, "_index", {
@@ -70,7 +76,7 @@ class FaissStore extends base_js_1.SaveableVectorStore {
     }
     get index() {
         if (!this._index) {
-            throw new Error("Vector store not initialised yet. Try calling `fromTexts` or `fromDocuments` first.");
+            throw new Error("Vector store not initialised yet. Try calling `fromTexts`, `fromDocuments` or `fromIndex` first.");
         }
         return this._index;
     }
@@ -134,6 +140,32 @@ class FaissStore extends base_js_1.SaveableVectorStore {
             ])),
         ]);
     }
+    async mergeFrom(targetIndex) {
+        const targetIndexDimensions = targetIndex.index.getDimension();
+        if (!this._index) {
+            const { IndexFlatL2 } = await FaissStore.importFaiss();
+            this._index = new IndexFlatL2(targetIndexDimensions);
+        }
+        const d = this.index.getDimension();
+        if (targetIndexDimensions !== d) {
+            throw new Error("Cannot merge indexes with different dimensions.");
+        }
+        const targetMapping = targetIndex.getMapping();
+        const targetDocstore = targetIndex.getDocstore();
+        const targetSize = targetIndex.index.ntotal();
+        const documentIds = [];
+        const currentDocstoreSize = this.index.ntotal();
+        for (let i = 0; i < targetSize; i += 1) {
+            const targetId = targetMapping[i];
+            documentIds.push(targetId);
+            const targetDocument = targetDocstore.search(targetId);
+            const id = currentDocstoreSize + i;
+            this._mapping[id] = targetId;
+            this.docstore.add({ [targetId]: targetDocument });
+        }
+        this.index.mergeFrom(targetIndex.index);
+        return documentIds;
+    }
     static async load(directory, embeddings) {
         const fs = await import("node:fs/promises");
         const path = await import("node:path");
@@ -231,6 +263,14 @@ class FaissStore extends base_js_1.SaveableVectorStore {
         await instance.addDocuments(docs);
         return instance;
     }
+    static async fromIndex(targetIndex, embeddings, dbConfig) {
+        const args = {
+            docstore: dbConfig?.docstore,
+        };
+        const instance = new this(embeddings, args);
+        await instance.mergeFrom(targetIndex);
+        return instance;
+    }
     static async importFaiss() {
         try {
             const { default: { IndexFlatL2 }, } = await import("faiss-node");