langchain 0.0.104 → 0.0.105

package/dist/base_language/count_tokens.cjs

@@ -56,13 +56,14 @@ const getModelContextSize = (modelName) => {
 };
 exports.getModelContextSize = getModelContextSize;
 const calculateMaxTokens = async ({ prompt, modelName, }) => {
-    // fallback to approximate calculation if tiktoken is not available
-    let numTokens = Math.ceil(prompt.length / 4);
+    let numTokens;
     try {
         numTokens = (await (0, tiktoken_js_1.encodingForModel)(modelName)).encode(prompt).length;
     }
     catch (error) {
         console.warn("Failed to calculate number of tokens, falling back to approximate count");
+        // fallback to approximate calculation if tiktoken is not available
+        numTokens = Math.ceil(prompt.length / 4);
     }
     const maxTokens = (0, exports.getModelContextSize)(modelName);
     return maxTokens - numTokens;

package/dist/base_language/count_tokens.js

@@ -50,13 +50,14 @@ export const getModelContextSize = (modelName) => {
     }
 };
 export const calculateMaxTokens = async ({ prompt, modelName, }) => {
-    // fallback to approximate calculation if tiktoken is not available
-    let numTokens = Math.ceil(prompt.length / 4);
+    let numTokens;
     try {
         numTokens = (await encodingForModel(modelName)).encode(prompt).length;
     }
     catch (error) {
         console.warn("Failed to calculate number of tokens, falling back to approximate count");
+        // fallback to approximate calculation if tiktoken is not available
+        numTokens = Math.ceil(prompt.length / 4);
     }
     const maxTokens = getModelContextSize(modelName);
     return maxTokens - numTokens;

package/dist/embeddings/openai.cjs

@@ -121,7 +121,7 @@ class OpenAIEmbeddings extends base_js_1.Embeddings {
         };
     }
     async embedDocuments(texts) {
-        const subPrompts = (0, chunk_js_1.chunkArray)(this.stripNewLines ? texts.map((t) => t.replaceAll("\n", " ")) : texts, this.batchSize);
+        const subPrompts = (0, chunk_js_1.chunkArray)(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
         const embeddings = [];
         for (let i = 0; i < subPrompts.length; i += 1) {
             const input = subPrompts[i];
@@ -138,7 +138,7 @@ class OpenAIEmbeddings extends base_js_1.Embeddings {
     async embedQuery(text) {
         const { data } = await this.embeddingWithRetry({
             model: this.modelName,
-            input: this.stripNewLines ? text.replaceAll("\n", " ") : text,
+            input: this.stripNewLines ? text.replace(/\n/g, " ") : text,
         });
         return data.data[0].embedding;
     }

package/dist/embeddings/openai.js

@@ -115,7 +115,7 @@ export class OpenAIEmbeddings extends Embeddings {
         };
     }
     async embedDocuments(texts) {
-        const subPrompts = chunkArray(this.stripNewLines ? texts.map((t) => t.replaceAll("\n", " ")) : texts, this.batchSize);
+        const subPrompts = chunkArray(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
         const embeddings = [];
         for (let i = 0; i < subPrompts.length; i += 1) {
             const input = subPrompts[i];
@@ -132,7 +132,7 @@ export class OpenAIEmbeddings extends Embeddings {
     async embedQuery(text) {
         const { data } = await this.embeddingWithRetry({
             model: this.modelName,
-            input: this.stripNewLines ? text.replaceAll("\n", " ") : text,
+            input: this.stripNewLines ? text.replace(/\n/g, " ") : text,
         });
         return data.data[0].embedding;
     }

package/dist/output_parsers/index.d.ts

@@ -5,4 +5,4 @@ export { OutputFixingParser } from "./fix.js";
 export { CombiningOutputParser } from "./combining.js";
 export { RouterOutputParser, RouterOutputParserInput } from "./router.js";
 export { CustomListOutputParser } from "./list.js";
-export { OutputFunctionsParser, JsonOutputFunctionsParser, JsonKeyOutputFunctionsParser, } from "../output_parsers/openai_functions.js";
+export { FunctionParameters, OutputFunctionsParser, JsonOutputFunctionsParser, JsonKeyOutputFunctionsParser, } from "../output_parsers/openai_functions.js";

package/dist/vectorstores/base.cjs

@@ -31,8 +31,8 @@ class VectorStoreRetriever extends index_js_1.BaseRetriever {
         const results = await this.vectorStore.similaritySearch(query, this.k, this.filter);
         return results;
     }
-    async addDocuments(documents) {
-        await this.vectorStore.addDocuments(documents);
+    async addDocuments(documents, options) {
+        return this.vectorStore.addDocuments(documents, options);
     }
 }
 exports.VectorStoreRetriever = VectorStoreRetriever;
@@ -47,6 +47,10 @@ class VectorStore {
         });
         this.embeddings = embeddings;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async delete(_params) {
+        throw new Error("Not implemented.");
+    }
     async similaritySearch(query, k = 4, filter = undefined) {
         const results = await this.similaritySearchVectorWithScore(await this.embeddings.embedQuery(query), k, filter);
         return results.map((result) => result[0]);

package/dist/vectorstores/base.d.ts

@@ -1,6 +1,7 @@
 import { Embeddings } from "../embeddings/base.js";
 import { Document } from "../document.js";
 import { BaseRetriever } from "../schema/index.js";
+type AddDocumentOptions = Record<string, any>;
 export interface VectorStoreRetrieverInput<V extends VectorStore> {
     vectorStore: V;
     k?: number;
@@ -12,14 +13,15 @@ export declare class VectorStoreRetriever<V extends VectorStore = VectorStore> e
     filter?: V["FilterType"];
     constructor(fields: VectorStoreRetrieverInput<V>);
     getRelevantDocuments(query: string): Promise<Document[]>;
-    addDocuments(documents: Document[]): Promise<void>;
+    addDocuments(documents: Document[], options?: AddDocumentOptions): Promise<string[] | void>;
 }
 export declare abstract class VectorStore {
     FilterType: object;
     embeddings: Embeddings;
     constructor(embeddings: Embeddings, _dbConfig: Record<string, any>);
-    abstract addVectors(vectors: number[][], documents: Document[]): Promise<void>;
-    abstract addDocuments(documents: Document[]): Promise<void>;
+    abstract addVectors(vectors: number[][], documents: Document[], options?: AddDocumentOptions): Promise<string[] | void>;
+    abstract addDocuments(documents: Document[], options?: AddDocumentOptions): Promise<string[] | void>;
+    delete(_params?: Record<string, any>): Promise<void>;
     abstract similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
     similaritySearch(query: string, k?: number, filter?: this["FilterType"] | undefined): Promise<Document[]>;
     similaritySearchWithScore(query: string, k?: number, filter?: this["FilterType"] | undefined): Promise<[Document, number][]>;
@@ -31,3 +33,4 @@ export declare abstract class SaveableVectorStore extends VectorStore {
     abstract save(directory: string): Promise<void>;
     static load(_directory: string, _embeddings: Embeddings): Promise<SaveableVectorStore>;
 }
+export {};

package/dist/vectorstores/base.js

@@ -28,8 +28,8 @@ export class VectorStoreRetriever extends BaseRetriever {
         const results = await this.vectorStore.similaritySearch(query, this.k, this.filter);
         return results;
     }
-    async addDocuments(documents) {
-        await this.vectorStore.addDocuments(documents);
+    async addDocuments(documents, options) {
+        return this.vectorStore.addDocuments(documents, options);
     }
 }
 export class VectorStore {
@@ -43,6 +43,10 @@ export class VectorStore {
         });
         this.embeddings = embeddings;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async delete(_params) {
+        throw new Error("Not implemented.");
+    }
     async similaritySearch(query, k = 4, filter = undefined) {
         const results = await this.similaritySearchVectorWithScore(await this.embeddings.embedQuery(query), k, filter);
         return results.map((result) => result[0]);

package/dist/vectorstores/chroma.cjs

@@ -77,9 +77,9 @@ class Chroma extends base_js_1.VectorStore {
         }
         this.filter = args.filter;
     }
-    async addDocuments(documents) {
+    async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
     async ensureCollection() {
         if (!this.collection) {
@@ -98,9 +98,9 @@ class Chroma extends base_js_1.VectorStore {
         }
         return this.collection;
     }
-    async addVectors(vectors, documents) {
+    async addVectors(vectors, documents, options) {
         if (vectors.length === 0) {
-            return;
+            return [];
         }
         if (this.numDimensions === undefined) {
             this.numDimensions = vectors[0].length;
@@ -111,14 +111,29 @@ class Chroma extends base_js_1.VectorStore {
         if (vectors[0].length !== this.numDimensions) {
             throw new Error(`Vectors must have the same length as the number of dimensions (${this.numDimensions})`);
         }
+        const documentIds = options?.ids ?? Array.from({ length: vectors.length }, () => uuid.v1());
         const collection = await this.ensureCollection();
-        const docstoreSize = await collection.count();
-        await collection.add({
-            ids: Array.from({ length: vectors.length }, (_, i) => (docstoreSize + i).toString()),
+        await collection.upsert({
+            ids: documentIds,
             embeddings: vectors,
             metadatas: documents.map(({ metadata }) => metadata),
             documents: documents.map(({ pageContent }) => pageContent),
         });
+        return documentIds;
+    }
+    async delete(params) {
+        const collection = await this.ensureCollection();
+        if (Array.isArray(params.ids)) {
+            await collection.delete({ ids: params.ids });
+        }
+        else if (params.filter) {
+            await collection.delete({
+                where: { ...params.filter },
+            });
+        }
+        else {
+            throw new Error(`You must provide one of "ids or "filter".`);
+        }
     }
     async similaritySearchVectorWithScore(query, k, filter) {
         if (filter && this.filter) {
@@ -164,7 +179,7 @@ class Chroma extends base_js_1.VectorStore {
             });
             docs.push(newDoc);
         }
-        return Chroma.fromDocuments(docs, embeddings, dbConfig);
+        return this.fromDocuments(docs, embeddings, dbConfig);
     }
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);

package/dist/vectorstores/chroma.d.ts

@@ -1,4 +1,5 @@
 import type { ChromaClient as ChromaClientT, Collection } from "chromadb";
+import type { Where } from "chromadb/dist/main/types.js";
 import { Embeddings } from "../embeddings/base.js";
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
@@ -13,8 +14,12 @@ export type ChromaLibArgs = {
     collectionName?: string;
     filter?: object;
 };
+export interface ChromaDeleteParams<T> {
+    ids?: string[];
+    filter?: T;
+}
 export declare class Chroma extends VectorStore {
-    FilterType: object;
+    FilterType: Where;
     index?: ChromaClientT;
     collection?: Collection;
     collectionName: string;
@@ -22,22 +27,18 @@ export declare class Chroma extends VectorStore {
     url: string;
     filter?: object;
     constructor(embeddings: Embeddings, args: ChromaLibArgs);
-    addDocuments(documents: Document[]): Promise<void>;
+    addDocuments(documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
     ensureCollection(): Promise<Collection>;
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
+    delete(params: ChromaDeleteParams<this["FilterType"]>): Promise<void>;
     similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document<Record<string, any>>, number][]>;
-    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: {
-        collectionName?: string;
-        url?: string;
-    }): Promise<Chroma>;
-    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: {
-        collectionName?: string;
-        url?: string;
-    }): Promise<Chroma>;
-    static fromExistingCollection(embeddings: Embeddings, dbConfig: {
-        collectionName: string;
-        url?: string;
-    }): Promise<Chroma>;
+    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: ChromaLibArgs): Promise<Chroma>;
+    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: ChromaLibArgs): Promise<Chroma>;
+    static fromExistingCollection(embeddings: Embeddings, dbConfig: ChromaLibArgs): Promise<Chroma>;
     static imports(): Promise<{
         ChromaClient: typeof ChromaClientT;
     }>;

package/dist/vectorstores/chroma.js

@@ -51,9 +51,9 @@ export class Chroma extends VectorStore {
         }
         this.filter = args.filter;
     }
-    async addDocuments(documents) {
+    async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
     async ensureCollection() {
         if (!this.collection) {
@@ -72,9 +72,9 @@ export class Chroma extends VectorStore {
         }
         return this.collection;
     }
-    async addVectors(vectors, documents) {
+    async addVectors(vectors, documents, options) {
         if (vectors.length === 0) {
-            return;
+            return [];
         }
         if (this.numDimensions === undefined) {
             this.numDimensions = vectors[0].length;
@@ -85,14 +85,29 @@ export class Chroma extends VectorStore {
         if (vectors[0].length !== this.numDimensions) {
             throw new Error(`Vectors must have the same length as the number of dimensions (${this.numDimensions})`);
         }
+        const documentIds = options?.ids ?? Array.from({ length: vectors.length }, () => uuid.v1());
         const collection = await this.ensureCollection();
-        const docstoreSize = await collection.count();
-        await collection.add({
-            ids: Array.from({ length: vectors.length }, (_, i) => (docstoreSize + i).toString()),
+        await collection.upsert({
+            ids: documentIds,
             embeddings: vectors,
             metadatas: documents.map(({ metadata }) => metadata),
             documents: documents.map(({ pageContent }) => pageContent),
         });
+        return documentIds;
+    }
+    async delete(params) {
+        const collection = await this.ensureCollection();
+        if (Array.isArray(params.ids)) {
+            await collection.delete({ ids: params.ids });
+        }
+        else if (params.filter) {
+            await collection.delete({
+                where: { ...params.filter },
+            });
+        }
+        else {
+            throw new Error(`You must provide one of "ids or "filter".`);
+        }
     }
     async similaritySearchVectorWithScore(query, k, filter) {
         if (filter && this.filter) {
@@ -138,7 +153,7 @@ export class Chroma extends VectorStore {
             });
             docs.push(newDoc);
         }
-        return Chroma.fromDocuments(docs, embeddings, dbConfig);
+        return this.fromDocuments(docs, embeddings, dbConfig);
     }
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);

package/dist/vectorstores/elasticsearch.cjs

@@ -1,6 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElasticVectorSearch = void 0;
+const uuid = __importStar(require("uuid"));
 const document_js_1 = require("../document.cjs");
 const base_js_1 = require("./base.cjs");
 class ElasticVectorSearch extends base_js_1.VectorStore {
@@ -56,15 +80,17 @@ class ElasticVectorSearch extends base_js_1.VectorStore {
         this.client = args.client;
         this.indexName = args.indexName ?? "documents";
     }
-    async addDocuments(documents) {
+    async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
-    async addVectors(vectors, documents) {
+    async addVectors(vectors, documents, options) {
         await this.ensureIndexExists(vectors[0].length, this.engine, this.similarity, this.efConstruction, this.m);
+        const documentIds = options?.ids ?? Array.from({ length: vectors.length }, () => uuid.v4());
         const operations = vectors.flatMap((embedding, idx) => [
             {
                 index: {
+                    _id: documentIds[idx],
                     _index: this.indexName,
                 },
             },
@@ -75,6 +101,7 @@ class ElasticVectorSearch extends base_js_1.VectorStore {
             },
         ]);
         await this.client.bulk({ refresh: true, operations });
+        return documentIds;
     }
     async similaritySearchVectorWithScore(query, k, filter) {
         const result = await this.client.search({
@@ -96,6 +123,15 @@ class ElasticVectorSearch extends base_js_1.VectorStore {
             hit._score,
         ]);
     }
+    async delete(params) {
+        const operations = params.ids.map((id) => ({
+            delete: {
+                _id: id,
+                _index: this.indexName,
+            },
+        }));
+        await this.client.bulk({ refresh: true, operations });
+    }
     static fromTexts(texts, metadatas, embeddings, args) {
         const documents = texts.map((text, idx) => {
             const metadata = Array.isArray(metadatas) ? metadatas[idx] : metadatas;

package/dist/vectorstores/elasticsearch.d.ts

@@ -27,9 +27,16 @@ export declare class ElasticVectorSearch extends VectorStore {
     private readonly m;
     private readonly candidates;
     constructor(embeddings: Embeddings, args: ElasticClientArgs);
-    addDocuments(documents: Document[]): Promise<void>;
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    addDocuments(documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
     similaritySearchVectorWithScore(query: number[], k: number, filter?: ElasticFilter | undefined): Promise<[Document, number][]>;
+    delete(params: {
+        ids: string[];
+    }): Promise<void>;
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, args: ElasticClientArgs): Promise<ElasticVectorSearch>;
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: ElasticClientArgs): Promise<ElasticVectorSearch>;
     static fromExistingIndex(embeddings: Embeddings, dbConfig: ElasticClientArgs): Promise<ElasticVectorSearch>;

package/dist/vectorstores/elasticsearch.js

@@ -1,3 +1,4 @@
+import * as uuid from "uuid";
 import { Document } from "../document.js";
 import { VectorStore } from "./base.js";
 export class ElasticVectorSearch extends VectorStore {
@@ -53,15 +54,17 @@ export class ElasticVectorSearch extends VectorStore {
         this.client = args.client;
         this.indexName = args.indexName ?? "documents";
     }
-    async addDocuments(documents) {
+    async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
-    async addVectors(vectors, documents) {
+    async addVectors(vectors, documents, options) {
         await this.ensureIndexExists(vectors[0].length, this.engine, this.similarity, this.efConstruction, this.m);
+        const documentIds = options?.ids ?? Array.from({ length: vectors.length }, () => uuid.v4());
         const operations = vectors.flatMap((embedding, idx) => [
             {
                 index: {
+                    _id: documentIds[idx],
                     _index: this.indexName,
                 },
             },
@@ -72,6 +75,7 @@ export class ElasticVectorSearch extends VectorStore {
             },
         ]);
         await this.client.bulk({ refresh: true, operations });
+        return documentIds;
     }
     async similaritySearchVectorWithScore(query, k, filter) {
         const result = await this.client.search({
@@ -93,6 +97,15 @@ export class ElasticVectorSearch extends VectorStore {
             hit._score,
         ]);
     }
+    async delete(params) {
+        const operations = params.ids.map((id) => ({
+            delete: {
+                _id: id,
+                _index: this.indexName,
+            },
+        }));
+        await this.client.bulk({ refresh: true, operations });
+    }
     static fromTexts(texts, metadatas, embeddings, args) {
         const documents = texts.map((text, idx) => {
             const metadata = Array.isArray(metadatas) ? metadatas[idx] : metadatas;

package/dist/vectorstores/faiss.cjs

@@ -76,7 +76,7 @@ class FaissStore extends base_js_1.SaveableVectorStore {
     }
     async addVectors(vectors, documents) {
         if (vectors.length === 0) {
-            return;
+            return [];
         }
         if (vectors.length !== documents.length) {
             throw new Error(`Vectors and documents must have the same length`);
@@ -91,13 +91,16 @@ class FaissStore extends base_js_1.SaveableVectorStore {
             throw new Error(`Vectors must have the same length as the number of dimensions (${d})`);
         }
         const docstoreSize = this.index.ntotal();
+        const documentIds = [];
         for (let i = 0; i < vectors.length; i += 1) {
             const documentId = uuid.v4();
+            documentIds.push(documentId);
             const id = docstoreSize + i;
             this.index.add(vectors[i]);
             this._mapping[id] = documentId;
             this.docstore.add({ [documentId]: documents[i] });
         }
+        return documentIds;
     }
     async similaritySearchVectorWithScore(query, k) {
         const d = this.index.getDimension();
@@ -230,16 +233,17 @@ class FaissStore extends base_js_1.SaveableVectorStore {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (err) {
-            throw new Error(`Could not import faiss-node. Please install faiss-node as a dependency with, e.g. \`npm install -S faiss-node\` and make sure you have \`libomp\` installed in your path.\n\nError: ${err?.message}`);
+            throw new Error(`Could not import faiss-node. Please install faiss-node as a dependency with, e.g. \`npm install -S faiss-node\`.\n\nError: ${err?.message}`);
         }
     }
     static async importPickleparser() {
         try {
             const { default: { Parser, NameRegistry }, } = await import("pickleparser");
             return { Parser, NameRegistry };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (err) {
-            throw new Error("Please install pickleparser as a dependency with, e.g. `npm install -S pickleparser`");
+            throw new Error(`Could not import pickleparser. Please install pickleparser as a dependency with, e.g. \`npm install -S pickleparser\`.\n\nError: ${err?.message}`);
         }
     }
 }

package/dist/vectorstores/faiss.d.ts

@@ -15,10 +15,10 @@ export declare class FaissStore extends SaveableVectorStore {
     docstore: SynchronousInMemoryDocstore;
     args: FaissLibArgs;
     constructor(embeddings: Embeddings, args: FaissLibArgs);
-    addDocuments(documents: Document[]): Promise<void>;
+    addDocuments(documents: Document[]): Promise<string[]>;
     get index(): IndexFlatL2;
     private set index(value);
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    addVectors(vectors: number[][], documents: Document[]): Promise<string[]>;
     similaritySearchVectorWithScore(query: number[], k: number): Promise<[Document<Record<string, any>>, number][]>;
     save(directory: string): Promise<void>;
     static load(directory: string, embeddings: Embeddings): Promise<FaissStore>;

package/dist/vectorstores/faiss.js

@@ -50,7 +50,7 @@ export class FaissStore extends SaveableVectorStore {
     }
     async addVectors(vectors, documents) {
         if (vectors.length === 0) {
-            return;
+            return [];
         }
         if (vectors.length !== documents.length) {
             throw new Error(`Vectors and documents must have the same length`);
@@ -65,13 +65,16 @@ export class FaissStore extends SaveableVectorStore {
             throw new Error(`Vectors must have the same length as the number of dimensions (${d})`);
         }
         const docstoreSize = this.index.ntotal();
+        const documentIds = [];
         for (let i = 0; i < vectors.length; i += 1) {
             const documentId = uuid.v4();
+            documentIds.push(documentId);
             const id = docstoreSize + i;
             this.index.add(vectors[i]);
             this._mapping[id] = documentId;
             this.docstore.add({ [documentId]: documents[i] });
         }
+        return documentIds;
     }
     async similaritySearchVectorWithScore(query, k) {
         const d = this.index.getDimension();
@@ -204,16 +207,17 @@ export class FaissStore extends SaveableVectorStore {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (err) {
-            throw new Error(`Could not import faiss-node. Please install faiss-node as a dependency with, e.g. \`npm install -S faiss-node\` and make sure you have \`libomp\` installed in your path.\n\nError: ${err?.message}`);
+            throw new Error(`Could not import faiss-node. Please install faiss-node as a dependency with, e.g. \`npm install -S faiss-node\`.\n\nError: ${err?.message}`);
         }
     }
     static async importPickleparser() {
         try {
             const { default: { Parser, NameRegistry }, } = await import("pickleparser");
             return { Parser, NameRegistry };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (err) {
-            throw new Error("Please install pickleparser as a dependency with, e.g. `npm install -S pickleparser`");
+            throw new Error(`Could not import pickleparser. Please install pickleparser as a dependency with, e.g. \`npm install -S pickleparser\`.\n\nError: ${err?.message}`);
         }
     }
 }

package/dist/vectorstores/hnswlib.cjs

@@ -172,9 +172,10 @@ class HNSWLib extends base_js_1.SaveableVectorStore {
         try {
             const { default: { HierarchicalNSW }, } = await import("hnswlib-node");
             return { HierarchicalNSW };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (err) {
-            throw new Error("Please install hnswlib-node as a dependency with, e.g. `npm install -S hnswlib-node`");
+            throw new Error(`Could not import hnswlib-node. Please install hnswlib-node as a dependency with, e.g. \`npm install -S hnswlib-node\`.\n\nError: ${err?.message}`);
         }
     }
 }

package/dist/vectorstores/hnswlib.js

@@ -169,9 +169,10 @@ export class HNSWLib extends SaveableVectorStore {
         try {
             const { default: { HierarchicalNSW }, } = await import("hnswlib-node");
             return { HierarchicalNSW };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (err) {
-            throw new Error("Please install hnswlib-node as a dependency with, e.g. `npm install -S hnswlib-node`");
+            throw new Error(`Could not import hnswlib-node. Please install hnswlib-node as a dependency with, e.g. \`npm install -S hnswlib-node\`.\n\nError: ${err?.message}`);
         }
     }
 }

package/dist/vectorstores/pinecone.cjs

@@ -64,11 +64,12 @@ class PineconeStore extends base_js_1.VectorStore {
         this.textKey = args.textKey ?? "text";
         this.filter = args.filter;
     }
-    async addDocuments(documents, ids) {
+    async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, ids);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
-    async addVectors(vectors, documents, ids) {
+    async addVectors(vectors, documents, options) {
+        const ids = Array.isArray(options) ? options : options?.ids;
         const documentIds = ids == null ? documents.map(() => uuid.v4()) : ids;
         const pineconeVectors = vectors.map((values, idx) => {
             // Pinecone doesn't support nested objects, so we flatten them
@@ -115,6 +116,31 @@ class PineconeStore extends base_js_1.VectorStore {
                 },
             });
         }
+        return documentIds;
+    }
+    async delete(params) {
+        const { namespace = this.namespace, deleteAll, ids, ...rest } = params;
+        if (deleteAll) {
+            await this.pineconeIndex.delete1({
+                deleteAll: true,
+                namespace,
+                ...rest,
+            });
+        }
+        else if (ids) {
+            const batchSize = 1000;
+            for (let i = 0; i < ids.length; i += batchSize) {
+                const batchIds = ids.slice(i, i + batchSize);
+                await this.pineconeIndex.delete1({
+                    ids: batchIds,
+                    namespace,
+                    ...rest,
+                });
+            }
+        }
+        else {
+            throw new Error("Either ids or delete_all must be provided.");
+        }
     }
     async similaritySearchVectorWithScore(query, k, filter) {
         if (filter && this.filter) {

package/dist/vectorstores/pinecone.d.ts

@@ -9,6 +9,11 @@ export interface PineconeLibArgs {
     namespace?: string;
     filter?: PineconeMetadata;
 }
+export type PineconeDeleteParams = {
+    ids?: string[];
+    deleteAll?: boolean;
+    namespace?: string;
+};
 export declare class PineconeStore extends VectorStore {
     FilterType: PineconeMetadata;
     textKey: string;
@@ -16,8 +21,13 @@ export declare class PineconeStore extends VectorStore {
     pineconeIndex: VectorOperationsApi;
     filter?: PineconeMetadata;
     constructor(embeddings: Embeddings, args: PineconeLibArgs);
-    addDocuments(documents: Document[], ids?: string[]): Promise<void>;
-    addVectors(vectors: number[][], documents: Document[], ids?: string[]): Promise<void>;
+    addDocuments(documents: Document[], options?: {
+        ids?: string[];
+    } | string[]): Promise<string[]>;
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    } | string[]): Promise<string[]>;
+    delete(params: PineconeDeleteParams): Promise<void>;
     similaritySearchVectorWithScore(query: number[], k: number, filter?: PineconeMetadata): Promise<[Document, number][]>;
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: {
         /**

package/dist/vectorstores/pinecone.js

@@ -35,11 +35,12 @@ export class PineconeStore extends VectorStore {
         this.textKey = args.textKey ?? "text";
         this.filter = args.filter;
     }
-    async addDocuments(documents, ids) {
+    async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, ids);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
-    async addVectors(vectors, documents, ids) {
+    async addVectors(vectors, documents, options) {
+        const ids = Array.isArray(options) ? options : options?.ids;
         const documentIds = ids == null ? documents.map(() => uuid.v4()) : ids;
         const pineconeVectors = vectors.map((values, idx) => {
             // Pinecone doesn't support nested objects, so we flatten them
@@ -86,6 +87,31 @@ export class PineconeStore extends VectorStore {
                 },
             });
         }
+        return documentIds;
+    }
+    async delete(params) {
+        const { namespace = this.namespace, deleteAll, ids, ...rest } = params;
+        if (deleteAll) {
+            await this.pineconeIndex.delete1({
+                deleteAll: true,
+                namespace,
+                ...rest,
+            });
+        }
+        else if (ids) {
+            const batchSize = 1000;
+            for (let i = 0; i < ids.length; i += batchSize) {
+                const batchIds = ids.slice(i, i + batchSize);
+                await this.pineconeIndex.delete1({
+                    ids: batchIds,
+                    namespace,
+                    ...rest,
+                });
+            }
+        }
+        else {
+            throw new Error("Either ids or delete_all must be provided.");
+        }
     }
     async similaritySearchVectorWithScore(query, k, filter) {
         if (filter && this.filter) {

package/dist/vectorstores/redis.cjs

@@ -69,7 +69,7 @@ class RedisVectorStore extends base_js_1.VectorStore {
     }
     async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
     async addVectors(vectors, documents, { keys, batchSize = 1000 } = {}) {
         // check if the index exists and create it if it doesn't

package/dist/vectorstores/redis.js

@@ -66,7 +66,7 @@ export class RedisVectorStore extends VectorStore {
     }
     async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
     async addVectors(vectors, documents, { keys, batchSize = 1000 } = {}) {
         // check if the index exists and create it if it doesn't

package/dist/vectorstores/supabase.cjs

@@ -48,12 +48,23 @@ class SupabaseVectorStore extends base_js_1.VectorStore {
         // upsert returns 500/502/504 (yes really any of them) if given too many rows/characters
         // ~2000 trips it, but my data is probably smaller than average pageContent and metadata
         const chunkSize = 500;
+        let ids = [];
         for (let i = 0; i < rows.length; i += chunkSize) {
             const chunk = rows.slice(i, i + chunkSize);
-            const res = await this.client.from(this.tableName).insert(chunk);
+            const res = await this.client.from(this.tableName).upsert(chunk).select();
             if (res.error) {
                 throw new Error(`Error inserting: ${res.error.message} ${res.status} ${res.statusText}`);
             }
+            if (res.data) {
+                ids = ids.concat(res.data.map((row) => row.id));
+            }
+        }
+        return ids;
+    }
+    async delete(params) {
+        const { ids } = params;
+        for (const id of ids) {
+            await this.client.from(this.tableName).delete().eq("id", id);
         }
     }
     async similaritySearchVectorWithScore(query, k, filter) {

package/dist/vectorstores/supabase.d.ts

@@ -19,8 +19,11 @@ export declare class SupabaseVectorStore extends VectorStore {
     queryName: string;
     filter?: SupabaseMetadata | SupabaseFilterRPCCall;
     constructor(embeddings: Embeddings, args: SupabaseLibArgs);
-    addDocuments(documents: Document[]): Promise<void>;
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    addDocuments(documents: Document[]): Promise<string[]>;
+    addVectors(vectors: number[][], documents: Document[]): Promise<string[]>;
+    delete(params: {
+        ids: string[];
+    }): Promise<void>;
     similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;

package/dist/vectorstores/supabase.js

@@ -45,12 +45,23 @@ export class SupabaseVectorStore extends VectorStore {
         // upsert returns 500/502/504 (yes really any of them) if given too many rows/characters
         // ~2000 trips it, but my data is probably smaller than average pageContent and metadata
         const chunkSize = 500;
+        let ids = [];
         for (let i = 0; i < rows.length; i += chunkSize) {
             const chunk = rows.slice(i, i + chunkSize);
-            const res = await this.client.from(this.tableName).insert(chunk);
+            const res = await this.client.from(this.tableName).upsert(chunk).select();
             if (res.error) {
                 throw new Error(`Error inserting: ${res.error.message} ${res.status} ${res.statusText}`);
             }
+            if (res.data) {
+                ids = ids.concat(res.data.map((row) => row.id));
+            }
+        }
+        return ids;
+    }
+    async delete(params) {
+        const { ids } = params;
+        for (const id of ids) {
+            await this.client.from(this.tableName).delete().eq("id", id);
         }
     }
     async similaritySearchVectorWithScore(query, k, filter) {

package/dist/vectorstores/tigris.cjs

@@ -39,17 +39,18 @@ class TigrisVectorStore extends base_js_1.VectorStore {
         this.embeddings = embeddings;
         this.index = args.index;
     }
-    async addDocuments(documents, ids) {
+    async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, ids);
+        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
-    async addVectors(vectors, documents, ids) {
+    async addVectors(vectors, documents, options) {
         if (vectors.length === 0) {
             return;
         }
         if (vectors.length !== documents.length) {
             throw new Error(`Vectors and metadatas must have the same length`);
         }
+        const ids = Array.isArray(options) ? options : options?.ids;
         const documentIds = ids == null ? documents.map(() => uuid.v4()) : ids;
         await this.index?.addDocumentsWithVectors({
             ids: documentIds,

package/dist/vectorstores/tigris.d.ts

@@ -8,8 +8,12 @@ export type TigrisLibArgs = {
 export declare class TigrisVectorStore extends VectorStore {
     index?: VectorDocumentStoreT;
     constructor(embeddings: Embeddings, args: TigrisLibArgs);
-    addDocuments(documents: Document[], ids?: string[]): Promise<void>;
-    addVectors(vectors: number[][], documents: Document[], ids?: string[]): Promise<void>;
+    addDocuments(documents: Document[], options?: {
+        ids?: string[];
+    } | string[]): Promise<void>;
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    } | string[]): Promise<void>;
     similaritySearchVectorWithScore(query: number[], k: number, filter?: object): Promise<[Document<Record<string, any>>, number][]>;
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: TigrisLibArgs): Promise<TigrisVectorStore>;
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: TigrisLibArgs): Promise<TigrisVectorStore>;

package/dist/vectorstores/tigris.js

@@ -13,17 +13,18 @@ export class TigrisVectorStore extends VectorStore {
         this.embeddings = embeddings;
         this.index = args.index;
     }
-    async addDocuments(documents, ids) {
+    async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, ids);
+        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
-    async addVectors(vectors, documents, ids) {
+    async addVectors(vectors, documents, options) {
         if (vectors.length === 0) {
             return;
         }
         if (vectors.length !== documents.length) {
             throw new Error(`Vectors and metadatas must have the same length`);
         }
+        const ids = Array.isArray(options) ? options : options?.ids;
         const documentIds = ids == null ? documents.map(() => uuid.v4()) : ids;
         await this.index?.addDocumentsWithVectors({
             ids: documentIds,

package/dist/vectorstores/weaviate.cjs

@@ -118,14 +118,15 @@ class WeaviateStore extends base_js_1.VectorStore {
             ];
         }
     }
-    async addVectors(vectors, documents) {
+    async addVectors(vectors, documents, options) {
+        const documentIds = options?.ids ?? documents.map((_) => uuid.v4());
         const batch = documents.map((document, index) => {
             if (Object.hasOwn(document.metadata, "id"))
                 throw new Error("Document inserted to Weaviate vectorstore should not have `id` in their metadata.");
             const flattenedMetadata = (0, exports.flattenObjectForWeaviate)(document.metadata);
             return {
                 class: this.indexName,
-                id: uuid.v4(),
+                id: documentIds[index],
                 vector: vectors[index],
                 properties: {
                     [this.textKey]: document.pageContent,
@@ -140,11 +141,22 @@ class WeaviateStore extends base_js_1.VectorStore {
                 .do();
         }
         catch (e) {
-            throw Error(`'Error in addDocuments' ${e}`);
+            throw Error(`'Error adding vectors' ${e}`);
         }
+        return documentIds;
     }
-    async addDocuments(documents) {
-        return this.addVectors(await this.embeddings.embedDocuments(documents.map((d) => d.pageContent)), documents);
+    async addDocuments(documents, options) {
+        return this.addVectors(await this.embeddings.embedDocuments(documents.map((d) => d.pageContent)), documents, options);
+    }
+    async delete(params) {
+        const { ids } = params;
+        for (const id of ids) {
+            await this.client.data
+                .deleter()
+                .withClassName(this.indexName)
+                .withId(id)
+                .do();
+        }
     }
     async similaritySearchVectorWithScore(query, k, filter) {
         try {

package/dist/vectorstores/weaviate.d.ts

@@ -24,8 +24,15 @@ export declare class WeaviateStore extends VectorStore {
     private textKey;
     private queryAttrs;
     constructor(embeddings: Embeddings, args: WeaviateLibArgs);
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
-    addDocuments(documents: Document[]): Promise<void>;
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
+    addDocuments(documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<string[]>;
+    delete(params: {
+        ids: string[];
+    }): Promise<void>;
     similaritySearchVectorWithScore(query: number[], k: number, filter?: WeaviateFilter): Promise<[Document, number][]>;
     static fromTexts(texts: string[], metadatas: object | object[], embeddings: Embeddings, args: WeaviateLibArgs): Promise<WeaviateStore>;
     static fromDocuments(docs: Document[], embeddings: Embeddings, args: WeaviateLibArgs): Promise<WeaviateStore>;

package/dist/vectorstores/weaviate.js

@@ -91,14 +91,15 @@ export class WeaviateStore extends VectorStore {
             ];
         }
     }
-    async addVectors(vectors, documents) {
+    async addVectors(vectors, documents, options) {
+        const documentIds = options?.ids ?? documents.map((_) => uuid.v4());
         const batch = documents.map((document, index) => {
             if (Object.hasOwn(document.metadata, "id"))
                 throw new Error("Document inserted to Weaviate vectorstore should not have `id` in their metadata.");
             const flattenedMetadata = flattenObjectForWeaviate(document.metadata);
             return {
                 class: this.indexName,
-                id: uuid.v4(),
+                id: documentIds[index],
                 vector: vectors[index],
                 properties: {
                     [this.textKey]: document.pageContent,
@@ -113,11 +114,22 @@ export class WeaviateStore extends VectorStore {
                 .do();
         }
         catch (e) {
-            throw Error(`'Error in addDocuments' ${e}`);
+            throw Error(`'Error adding vectors' ${e}`);
         }
+        return documentIds;
     }
-    async addDocuments(documents) {
-        return this.addVectors(await this.embeddings.embedDocuments(documents.map((d) => d.pageContent)), documents);
+    async addDocuments(documents, options) {
+        return this.addVectors(await this.embeddings.embedDocuments(documents.map((d) => d.pageContent)), documents, options);
+    }
+    async delete(params) {
+        const { ids } = params;
+        for (const id of ids) {
+            await this.client.data
+                .deleter()
+                .withClassName(this.indexName)
+                .withId(id)
+                .do();
+        }
     }
     async similaritySearchVectorWithScore(query, k, filter) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "0.0.104",
+  "version": "0.0.105",
   "description": "Typescript bindings for langchain",
   "type": "module",
   "engines": {
@@ -516,7 +516,7 @@
     "apify-client": "^2.7.1",
     "axios": "^0.26.0",
     "cheerio": "^1.0.0-rc.12",
-    "chromadb": "^1.5.2",
+    "chromadb": "^1.5.3",
     "cohere-ai": "^5.0.2",
     "d3-dsv": "^2.0.0",
     "dotenv": "^16.0.3",
@@ -588,7 +588,7 @@
     "apify-client": "^2.7.1",
     "axios": "*",
     "cheerio": "^1.0.0-rc.12",
-    "chromadb": "^1.5.2",
+    "chromadb": "^1.5.3",
     "cohere-ai": "^5.0.2",
     "d3-dsv": "^2.0.0",
     "epub2": "^3.0.1",