langchain 0.0.204-rc.0 → 0.0.204-rc.2

package/dist/util/convex.js

@@ -1,74 +1 @@
-/* eslint-disable spaced-comment */
-// eslint-disable-next-line import/no-extraneous-dependencies
-import { internalQueryGeneric as internalQuery, internalMutationGeneric as internalMutation, } from "convex/server";
-// eslint-disable-next-line import/no-extraneous-dependencies
-import { v } from "convex/values";
-export const get = /*#__PURE__*/ internalQuery({
-    args: {
-        id: /*#__PURE__*/ v.string(),
-    },
-    handler: async (ctx, args) => {
-        const result = await ctx.db.get(args.id);
-        return result;
-    },
-});
-export const insert = /*#__PURE__*/ internalMutation({
-    args: {
-        table: /*#__PURE__*/ v.string(),
-        document: /*#__PURE__*/ v.any(),
-    },
-    handler: async (ctx, args) => {
-        await ctx.db.insert(args.table, args.document);
-    },
-});
-export const lookup = /*#__PURE__*/ internalQuery({
-    args: {
-        table: /*#__PURE__*/ v.string(),
-        index: /*#__PURE__*/ v.string(),
-        keyField: /*#__PURE__*/ v.string(),
-        key: /*#__PURE__*/ v.string(),
-    },
-    handler: async (ctx, args) => {
-        const result = await ctx.db
-            .query(args.table)
-            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
-            .collect();
-        return result;
-    },
-});
-export const upsert = /*#__PURE__*/ internalMutation({
-    args: {
-        table: /*#__PURE__*/ v.string(),
-        index: /*#__PURE__*/ v.string(),
-        keyField: /*#__PURE__*/ v.string(),
-        key: /*#__PURE__*/ v.string(),
-        document: /*#__PURE__*/ v.any(),
-    },
-    handler: async (ctx, args) => {
-        const existing = await ctx.db
-            .query(args.table)
-            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
-            .unique();
-        if (existing !== null) {
-            await ctx.db.replace(existing._id, args.document);
-        }
-        else {
-            await ctx.db.insert(args.table, args.document);
-        }
-    },
-});
-export const deleteMany = /*#__PURE__*/ internalMutation({
-    args: {
-        table: /*#__PURE__*/ v.string(),
-        index: /*#__PURE__*/ v.string(),
-        keyField: /*#__PURE__*/ v.string(),
-        key: /*#__PURE__*/ v.string(),
-    },
-    handler: async (ctx, args) => {
-        const existing = await ctx.db
-            .query(args.table)
-            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
-            .collect();
-        await Promise.all(existing.map((doc) => ctx.db.delete(doc._id)));
-    },
-});
+export * from "@langchain/community/util/convex";

package/dist/vectorstores/memory.cjs

@@ -1,17 +1,145 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@langchain/community/vectorstores/memory"), exports);
+exports.MemoryVectorStore = void 0;
+const ml_distance_1 = require("ml-distance");
+const vectorstores_1 = require("@langchain/core/vectorstores");
+const documents_1 = require("@langchain/core/documents");
+/**
+ * Class that extends `VectorStore` to store vectors in memory. Provides
+ * methods for adding documents, performing similarity searches, and
+ * creating instances from texts, documents, or an existing index.
+ */
+class MemoryVectorStore extends vectorstores_1.VectorStore {
+    _vectorstoreType() {
+        return "memory";
+    }
+    constructor(embeddings, { similarity, ...rest } = {}) {
+        super(embeddings, rest);
+        Object.defineProperty(this, "memoryVectors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "similarity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.similarity = similarity ?? ml_distance_1.similarity.cosine;
+    }
+    /**
+     * Method to add documents to the memory vector store. It extracts the
+     * text from each document, generates embeddings for them, and adds the
+     * resulting vectors to the store.
+     * @param documents Array of `Document` instances to be added to the store.
+     * @returns Promise that resolves when all documents have been added.
+     */
+    async addDocuments(documents) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+    }
+    /**
+     * Method to add vectors to the memory vector store. It creates
+     * `MemoryVector` instances for each vector and document pair and adds
+     * them to the store.
+     * @param vectors Array of vectors to be added to the store.
+     * @param documents Array of `Document` instances corresponding to the vectors.
+     * @returns Promise that resolves when all vectors have been added.
+     */
+    async addVectors(vectors, documents) {
+        const memoryVectors = vectors.map((embedding, idx) => ({
+            content: documents[idx].pageContent,
+            embedding,
+            metadata: documents[idx].metadata,
+        }));
+        this.memoryVectors = this.memoryVectors.concat(memoryVectors);
+    }
+    /**
+     * Method to perform a similarity search in the memory vector store. It
+     * calculates the similarity between the query vector and each vector in
+     * the store, sorts the results by similarity, and returns the top `k`
+     * results along with their scores.
+     * @param query Query vector to compare against the vectors in the store.
+     * @param k Number of top results to return.
+     * @param filter Optional filter function to apply to the vectors before performing the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
+     */
+    async similaritySearchVectorWithScore(query, k, filter) {
+        const filterFunction = (memoryVector) => {
+            if (!filter) {
+                return true;
+            }
+            const doc = new documents_1.Document({
+                metadata: memoryVector.metadata,
+                pageContent: memoryVector.content,
+            });
+            return filter(doc);
+        };
+        const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);
+        const searches = filteredMemoryVectors
+            .map((vector, index) => ({
+            similarity: this.similarity(query, vector.embedding),
+            index,
+        }))
+            .sort((a, b) => (a.similarity > b.similarity ? -1 : 0))
+            .slice(0, k);
+        const result = searches.map((search) => [
+            new documents_1.Document({
+                metadata: filteredMemoryVectors[search.index].metadata,
+                pageContent: filteredMemoryVectors[search.index].content,
+            }),
+            search.similarity,
+        ]);
+        return result;
+    }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * texts. It creates a `Document` for each text and metadata pair, and
+     * adds them to the store.
+     * @param texts Array of texts to be added to the store.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the texts.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
+        const docs = [];
+        for (let i = 0; i < texts.length; i += 1) {
+            const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
+            const newDoc = new documents_1.Document({
+                pageContent: texts[i],
+                metadata,
+            });
+            docs.push(newDoc);
+        }
+        return MemoryVectorStore.fromDocuments(docs, embeddings, dbConfig);
+    }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * `Document` instances. It adds the documents to the store.
+     * @param docs Array of `Document` instances to be added to the store.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static async fromDocuments(docs, embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        await instance.addDocuments(docs);
+        return instance;
+    }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an existing
+     * index. It creates a new `MemoryVectorStore` instance without adding any
+     * documents or vectors.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static async fromExistingIndex(embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        return instance;
+    }
+}
+exports.MemoryVectorStore = MemoryVectorStore;

package/dist/vectorstores/memory.d.ts

@@ -1 +1,92 @@
-export * from "@langchain/community/vectorstores/memory";
+import { similarity as ml_distance_similarity } from "ml-distance";
+import { VectorStore } from "@langchain/core/vectorstores";
+import { Embeddings } from "@langchain/core/embeddings";
+import { Document } from "@langchain/core/documents";
+/**
+ * Interface representing a vector in memory. It includes the content
+ * (text), the corresponding embedding (vector), and any associated
+ * metadata.
+ */
+interface MemoryVector {
+    content: string;
+    embedding: number[];
+    metadata: Record<string, any>;
+}
+/**
+ * Interface for the arguments that can be passed to the
+ * `MemoryVectorStore` constructor. It includes an optional `similarity`
+ * function.
+ */
+export interface MemoryVectorStoreArgs {
+    similarity?: typeof ml_distance_similarity.cosine;
+}
+/**
+ * Class that extends `VectorStore` to store vectors in memory. Provides
+ * methods for adding documents, performing similarity searches, and
+ * creating instances from texts, documents, or an existing index.
+ */
+export declare class MemoryVectorStore extends VectorStore {
+    FilterType: (doc: Document) => boolean;
+    memoryVectors: MemoryVector[];
+    similarity: typeof ml_distance_similarity.cosine;
+    _vectorstoreType(): string;
+    constructor(embeddings: Embeddings, { similarity, ...rest }?: MemoryVectorStoreArgs);
+    /**
+     * Method to add documents to the memory vector store. It extracts the
+     * text from each document, generates embeddings for them, and adds the
+     * resulting vectors to the store.
+     * @param documents Array of `Document` instances to be added to the store.
+     * @returns Promise that resolves when all documents have been added.
+     */
+    addDocuments(documents: Document[]): Promise<void>;
+    /**
+     * Method to add vectors to the memory vector store. It creates
+     * `MemoryVector` instances for each vector and document pair and adds
+     * them to the store.
+     * @param vectors Array of vectors to be added to the store.
+     * @param documents Array of `Document` instances corresponding to the vectors.
+     * @returns Promise that resolves when all vectors have been added.
+     */
+    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Method to perform a similarity search in the memory vector store. It
+     * calculates the similarity between the query vector and each vector in
+     * the store, sorts the results by similarity, and returns the top `k`
+     * results along with their scores.
+     * @param query Query vector to compare against the vectors in the store.
+     * @param k Number of top results to return.
+     * @param filter Optional filter function to apply to the vectors before performing the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
+     */
+    similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * texts. It creates a `Document` for each text and metadata pair, and
+     * adds them to the store.
+     * @param texts Array of texts to be added to the store.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the texts.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * `Document` instances. It adds the documents to the store.
+     * @param docs Array of `Document` instances to be added to the store.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an existing
+     * index. It creates a new `MemoryVectorStore` instance without adding any
+     * documents or vectors.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static fromExistingIndex(embeddings: Embeddings, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;
+}
+export {};

package/dist/vectorstores/memory.js

@@ -1 +1,141 @@
-export * from "@langchain/community/vectorstores/memory";
+import { similarity as ml_distance_similarity } from "ml-distance";
+import { VectorStore } from "@langchain/core/vectorstores";
+import { Document } from "@langchain/core/documents";
+/**
+ * Class that extends `VectorStore` to store vectors in memory. Provides
+ * methods for adding documents, performing similarity searches, and
+ * creating instances from texts, documents, or an existing index.
+ */
+export class MemoryVectorStore extends VectorStore {
+    _vectorstoreType() {
+        return "memory";
+    }
+    constructor(embeddings, { similarity, ...rest } = {}) {
+        super(embeddings, rest);
+        Object.defineProperty(this, "memoryVectors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "similarity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.similarity = similarity ?? ml_distance_similarity.cosine;
+    }
+    /**
+     * Method to add documents to the memory vector store. It extracts the
+     * text from each document, generates embeddings for them, and adds the
+     * resulting vectors to the store.
+     * @param documents Array of `Document` instances to be added to the store.
+     * @returns Promise that resolves when all documents have been added.
+     */
+    async addDocuments(documents) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+    }
+    /**
+     * Method to add vectors to the memory vector store. It creates
+     * `MemoryVector` instances for each vector and document pair and adds
+     * them to the store.
+     * @param vectors Array of vectors to be added to the store.
+     * @param documents Array of `Document` instances corresponding to the vectors.
+     * @returns Promise that resolves when all vectors have been added.
+     */
+    async addVectors(vectors, documents) {
+        const memoryVectors = vectors.map((embedding, idx) => ({
+            content: documents[idx].pageContent,
+            embedding,
+            metadata: documents[idx].metadata,
+        }));
+        this.memoryVectors = this.memoryVectors.concat(memoryVectors);
+    }
+    /**
+     * Method to perform a similarity search in the memory vector store. It
+     * calculates the similarity between the query vector and each vector in
+     * the store, sorts the results by similarity, and returns the top `k`
+     * results along with their scores.
+     * @param query Query vector to compare against the vectors in the store.
+     * @param k Number of top results to return.
+     * @param filter Optional filter function to apply to the vectors before performing the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
+     */
+    async similaritySearchVectorWithScore(query, k, filter) {
+        const filterFunction = (memoryVector) => {
+            if (!filter) {
+                return true;
+            }
+            const doc = new Document({
+                metadata: memoryVector.metadata,
+                pageContent: memoryVector.content,
+            });
+            return filter(doc);
+        };
+        const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);
+        const searches = filteredMemoryVectors
+            .map((vector, index) => ({
+            similarity: this.similarity(query, vector.embedding),
+            index,
+        }))
+            .sort((a, b) => (a.similarity > b.similarity ? -1 : 0))
+            .slice(0, k);
+        const result = searches.map((search) => [
+            new Document({
+                metadata: filteredMemoryVectors[search.index].metadata,
+                pageContent: filteredMemoryVectors[search.index].content,
+            }),
+            search.similarity,
+        ]);
+        return result;
+    }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * texts. It creates a `Document` for each text and metadata pair, and
+     * adds them to the store.
+     * @param texts Array of texts to be added to the store.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the texts.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
+        const docs = [];
+        for (let i = 0; i < texts.length; i += 1) {
+            const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
+            const newDoc = new Document({
+                pageContent: texts[i],
+                metadata,
+            });
+            docs.push(newDoc);
+        }
+        return MemoryVectorStore.fromDocuments(docs, embeddings, dbConfig);
+    }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an array of
+     * `Document` instances. It adds the documents to the store.
+     * @param docs Array of `Document` instances to be added to the store.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static async fromDocuments(docs, embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        await instance.addDocuments(docs);
+        return instance;
+    }
+    /**
+     * Static method to create a `MemoryVectorStore` instance from an existing
+     * index. It creates a new `MemoryVectorStore` instance without adding any
+     * documents or vectors.
+     * @param embeddings `Embeddings` instance used to generate embeddings for the documents.
+     * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.
+     * @returns Promise that resolves with a new `MemoryVectorStore` instance.
+     */
+    static async fromExistingIndex(embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        return instance;
+    }
+}