langchain 0.0.202 → 0.0.204-rc.0

package/dist/vectorstores/prisma.js

@@ -1,304 +1 @@
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-const IdColumnSymbol = Symbol("id");
-const ContentColumnSymbol = Symbol("content");
-const OpMap = {
-    equals: "=",
-    in: "IN",
-    isNull: "IS NULL",
-    isNotNull: "IS NOT NULL",
-    like: "LIKE",
-    lt: "<",
-    lte: "<=",
-    gt: ">",
-    gte: ">=",
-    not: "<>",
-};
-/**
- * A specific implementation of the VectorStore class that is designed to
- * work with Prisma. It provides methods for adding models, documents, and
- * vectors, as well as for performing similarity searches.
- */
-class PrismaVectorStore extends VectorStore {
-    _vectorstoreType() {
-        return "prisma";
-    }
-    constructor(embeddings, config) {
-        super(embeddings, {});
-        Object.defineProperty(this, "tableName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "vectorColumnName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "selectColumns", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "filter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "idColumn", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "contentColumn", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "db", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "Prisma", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.Prisma = config.prisma;
-        this.db = config.db;
-        const entries = Object.entries(config.columns);
-        const idColumn = entries.find((i) => i[1] === IdColumnSymbol)?.[0];
-        const contentColumn = entries.find((i) => i[1] === ContentColumnSymbol)?.[0];
-        if (idColumn == null)
-            throw new Error("Missing ID column");
-        if (contentColumn == null)
-            throw new Error("Missing content column");
-        this.idColumn = idColumn;
-        this.contentColumn = contentColumn;
-        this.tableName = config.tableName;
-        this.vectorColumnName = config.vectorColumnName;
-        this.selectColumns = entries
-            .map(([key, alias]) => (alias && key) || null)
-            .filter((x) => !!x);
-        if (config.filter) {
-            this.filter = config.filter;
-        }
-    }
-    /**
-     * Creates a new PrismaVectorStore with the specified model.
-     * @param db The PrismaClient instance.
-     * @returns An object with create, fromTexts, and fromDocuments methods.
-     */
-    static withModel(db) {
-        function create(embeddings, config) {
-            return new PrismaVectorStore(embeddings, { ...config, db });
-        }
-        async function 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 PrismaVectorStore.fromDocuments(docs, embeddings, {
-                ...dbConfig,
-                db,
-            });
-        }
-        async function fromDocuments(docs, embeddings, dbConfig) {
-            const instance = new PrismaVectorStore(embeddings, { ...dbConfig, db });
-            await instance.addDocuments(docs);
-            return instance;
-        }
-        return { create, fromTexts, fromDocuments };
-    }
-    /**
-     * Adds the specified models to the store.
-     * @param models The models to add.
-     * @returns A promise that resolves when the models have been added.
-     */
-    async addModels(models) {
-        return this.addDocuments(models.map((metadata) => {
-            const pageContent = metadata[this.contentColumn];
-            if (typeof pageContent !== "string")
-                throw new Error("Content column must be a string");
-            return new Document({ pageContent, metadata });
-        }));
-    }
-    /**
-     * Adds the specified documents to the store.
-     * @param documents The documents to add.
-     * @returns A promise that resolves when the documents have been added.
-     */
-    async addDocuments(documents) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
-    }
-    /**
-     * Adds the specified vectors to the store.
-     * @param vectors The vectors to add.
-     * @param documents The documents associated with the vectors.
-     * @returns A promise that resolves when the vectors have been added.
-     */
-    async addVectors(vectors, documents) {
-        // table name, column name cannot be parametrised
-        // these fields are thus not escaped by Prisma and can be dangerous if user input is used
-        const idColumnRaw = this.Prisma.raw(`"${this.idColumn}"`);
-        const tableNameRaw = this.Prisma.raw(`"${this.tableName}"`);
-        const vectorColumnRaw = this.Prisma.raw(`"${this.vectorColumnName}"`);
-        await this.db.$transaction(vectors.map((vector, idx) => this.db.$executeRaw `
-          UPDATE ${tableNameRaw}
-          SET ${vectorColumnRaw} = ${`[${vector.join(",")}]`}::vector
-          WHERE ${idColumnRaw} = ${documents[idx].metadata[this.idColumn]}
-        `));
-    }
-    /**
-     * Performs a similarity search with the specified query.
-     * @param query The query to use for the similarity search.
-     * @param k The number of results to return.
-     * @param _filter The filter to apply to the results.
-     * @param _callbacks The callbacks to use during the search.
-     * @returns A promise that resolves with the search results.
-     */
-    async similaritySearch(query, k = 4, _filter = undefined, // not used. here to make the interface compatible with the other stores
-    _callbacks = undefined // implement passing to embedQuery later
-    ) {
-        const results = await this.similaritySearchVectorWithScore(await this.embeddings.embedQuery(query), k);
-        return results.map((result) => result[0]);
-    }
-    /**
-     * Performs a similarity search with the specified query and returns the
-     * results along with their scores.
-     * @param query The query to use for the similarity search.
-     * @param k The number of results to return.
-     * @param filter The filter to apply to the results.
-     * @param _callbacks The callbacks to use during the search.
-     * @returns A promise that resolves with the search results and their scores.
-     */
-    async similaritySearchWithScore(query, k, filter, _callbacks = undefined // implement passing to embedQuery later
-    ) {
-        return super.similaritySearchWithScore(query, k, filter);
-    }
-    /**
-     * Performs a similarity search with the specified vector and returns the
-     * results along with their scores.
-     * @param query The vector to use for the similarity search.
-     * @param k The number of results to return.
-     * @param filter The filter to apply to the results.
-     * @returns A promise that resolves with the search results and their scores.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        // table name, column names cannot be parametrised
-        // these fields are thus not escaped by Prisma and can be dangerous if user input is used
-        const vectorColumnRaw = this.Prisma.raw(`"${this.vectorColumnName}"`);
-        const tableNameRaw = this.Prisma.raw(`"${this.tableName}"`);
-        const selectRaw = this.Prisma.raw(this.selectColumns.map((x) => `"${x}"`).join(", "));
-        const vector = `[${query.join(",")}]`;
-        const articles = await this.db.$queryRaw(this.Prisma.join([
-            this.Prisma.sql `
-            SELECT ${selectRaw}, ${vectorColumnRaw} <=> ${vector}::vector as "_distance"
-            FROM ${tableNameRaw}
-          `,
-            this.buildSqlFilterStr(filter ?? this.filter),
-            this.Prisma.sql `
-            ORDER BY "_distance" ASC
-            LIMIT ${k};
-          `,
-        ].filter((x) => x != null), ""));
-        const results = [];
-        for (const article of articles) {
-            if (article._distance != null && article[this.contentColumn] != null) {
-                results.push([
-                    new Document({
-                        pageContent: article[this.contentColumn],
-                        metadata: article,
-                    }),
-                    article._distance,
-                ]);
-            }
-        }
-        return results;
-    }
-    buildSqlFilterStr(filter) {
-        if (filter == null)
-            return null;
-        return this.Prisma.join(Object.entries(filter).flatMap(([key, ops]) => Object.entries(ops).map(([opName, value]) => {
-            // column name, operators cannot be parametrised
-            // these fields are thus not escaped by Prisma and can be dangerous if user input is used
-            const opNameKey = opName;
-            const colRaw = this.Prisma.raw(`"${key}"`);
-            const opRaw = this.Prisma.raw(OpMap[opNameKey]);
-            switch (OpMap[opNameKey]) {
-                case OpMap.in: {
-                    if (!Array.isArray(value) ||
-                        !value.every((v) => typeof v === "string")) {
-                        throw new Error(`Invalid filter: IN operator requires an array of strings. Received: ${JSON.stringify(value, null, 2)}`);
-                    }
-                    return this.Prisma.sql `${colRaw} ${opRaw} (${this.Prisma.join(value)})`;
-                }
-                case OpMap.isNull:
-                case OpMap.isNotNull:
-                    return this.Prisma.sql `${colRaw} ${opRaw}`;
-                default:
-                    return this.Prisma.sql `${colRaw} ${opRaw} ${value}`;
-            }
-        })), " AND ", " WHERE ");
-    }
-    /**
-     * Creates a new PrismaVectorStore from the specified texts.
-     * @param texts The texts to use to create the store.
-     * @param metadatas The metadata for the texts.
-     * @param embeddings The embeddings to use.
-     * @param dbConfig The database configuration.
-     * @returns A promise that resolves with the new PrismaVectorStore.
-     */
-    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 PrismaVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Creates a new PrismaVectorStore from the specified documents.
-     * @param docs The documents to use to create the store.
-     * @param embeddings The embeddings to use.
-     * @param dbConfig The database configuration.
-     * @returns A promise that resolves with the new PrismaVectorStore.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = new PrismaVectorStore(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-}
-Object.defineProperty(PrismaVectorStore, "IdColumn", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: IdColumnSymbol
-});
-Object.defineProperty(PrismaVectorStore, "ContentColumn", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: ContentColumnSymbol
-});
-export { PrismaVectorStore };
+export * from "@langchain/community/vectorstores/prisma";

package/dist/vectorstores/qdrant.cjs

@@ -1,197 +1,17 @@
 "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 });
-exports.QdrantVectorStore = void 0;
-const js_client_rest_1 = require("@qdrant/js-client-rest");
-const uuid_1 = require("uuid");
-const base_js_1 = require("./base.cjs");
-const document_js_1 = require("../document.cjs");
-const env_js_1 = require("../util/env.cjs");
-/**
- * Class that extends the `VectorStore` base class to interact with a
- * Qdrant database. It includes methods for adding documents and vectors
- * to the Qdrant database, searching for similar vectors, and ensuring the
- * existence of a collection in the database.
- */
-class QdrantVectorStore extends base_js_1.VectorStore {
-    get lc_secrets() {
-        return {
-            apiKey: "QDRANT_API_KEY",
-            url: "QDRANT_URL",
-        };
-    }
-    _vectorstoreType() {
-        return "qdrant";
-    }
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        Object.defineProperty(this, "client", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "collectionName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "collectionConfig", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        const url = args.url ?? (0, env_js_1.getEnvironmentVariable)("QDRANT_URL");
-        const apiKey = args.apiKey ?? (0, env_js_1.getEnvironmentVariable)("QDRANT_API_KEY");
-        if (!args.client && !url) {
-            throw new Error("Qdrant client or url address must be set.");
-        }
-        this.client =
-            args.client ||
-                new js_client_rest_1.QdrantClient({
-                    url,
-                    apiKey,
-                });
-        this.collectionName = args.collectionName ?? "documents";
-        this.collectionConfig = args.collectionConfig;
-    }
-    /**
-     * Method to add documents to the Qdrant database. It generates vectors
-     * from the documents using the `Embeddings` instance and then adds the
-     * vectors to the database.
-     * @param documents Array of `Document` instances to be added to the Qdrant database.
-     * @returns Promise that resolves when the documents have been added to the database.
-     */
-    async addDocuments(documents) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents);
-    }
-    /**
-     * Method to add vectors to the Qdrant database. Each vector is associated
-     * with a document, which is stored as the payload for a point in the
-     * database.
-     * @param vectors Array of vectors to be added to the Qdrant database.
-     * @param documents Array of `Document` instances associated with the vectors.
-     * @returns Promise that resolves when the vectors have been added to the database.
-     */
-    async addVectors(vectors, documents) {
-        if (vectors.length === 0) {
-            return;
-        }
-        await this.ensureCollection();
-        const points = vectors.map((embedding, idx) => ({
-            id: (0, uuid_1.v4)(),
-            vector: embedding,
-            payload: {
-                content: documents[idx].pageContent,
-                metadata: documents[idx].metadata,
-            },
-        }));
-        try {
-            await this.client.upsert(this.collectionName, {
-                wait: true,
-                points,
-            });
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (e) {
-            const error = new Error(`${e?.status ?? "Undefined error code"} ${e?.message}: ${e?.data?.status?.error}`);
-            throw error;
-        }
-    }
-    /**
-     * Method to search for vectors in the Qdrant database that are similar to
-     * a given query vector. The search results include the score and payload
-     * (metadata and content) for each similar vector.
-     * @param query Query vector to search for similar vectors in the Qdrant database.
-     * @param k Optional number of similar vectors to return. If not specified, all similar vectors are returned.
-     * @param filter Optional filter to apply to the search results.
-     * @returns Promise that resolves with an array of tuples, where each tuple includes a `Document` instance and a score for a similar vector.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        if (!query) {
-            return [];
-        }
-        await this.ensureCollection();
-        const results = await this.client.search(this.collectionName, {
-            vector: query,
-            limit: k,
-            filter,
-        });
-        const result = results.map((res) => [
-            new document_js_1.Document({
-                metadata: res.payload.metadata,
-                pageContent: res.payload.content,
-            }),
-            res.score,
-        ]);
-        return result;
-    }
-    /**
-     * Method to ensure the existence of a collection in the Qdrant database.
-     * If the collection does not exist, it is created.
-     * @returns Promise that resolves when the existence of the collection has been ensured.
-     */
-    async ensureCollection() {
-        const response = await this.client.getCollections();
-        const collectionNames = response.collections.map((collection) => collection.name);
-        if (!collectionNames.includes(this.collectionName)) {
-            const collectionConfig = this.collectionConfig ?? {
-                vectors: {
-                    size: (await this.embeddings.embedQuery("test")).length,
-                    distance: "Cosine",
-                },
-            };
-            await this.client.createCollection(this.collectionName, collectionConfig);
-        }
-    }
-    /**
-     * Static method to create a `QdrantVectorStore` instance from texts. Each
-     * text is associated with metadata and converted to a `Document`
-     * instance, which is then added to the Qdrant database.
-     * @param texts Array of texts to be converted to `Document` instances and added to the Qdrant database.
-     * @param metadatas Array or single object of metadata to be associated with the texts.
-     * @param embeddings `Embeddings` instance used to generate vectors from the texts.
-     * @param dbConfig `QdrantLibArgs` instance specifying the configuration for the Qdrant database.
-     * @returns Promise that resolves with a new `QdrantVectorStore` 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_js_1.Document({
-                pageContent: texts[i],
-                metadata,
-            });
-            docs.push(newDoc);
-        }
-        return QdrantVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Static method to create a `QdrantVectorStore` instance from `Document`
-     * instances. The documents are added to the Qdrant database.
-     * @param docs Array of `Document` instances to be added to the Qdrant database.
-     * @param embeddings `Embeddings` instance used to generate vectors from the documents.
-     * @param dbConfig `QdrantLibArgs` instance specifying the configuration for the Qdrant database.
-     * @returns Promise that resolves with a new `QdrantVectorStore` instance.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-    /**
-     * Static method to create a `QdrantVectorStore` instance from an existing
-     * collection in the Qdrant database.
-     * @param embeddings `Embeddings` instance used to generate vectors from the documents in the collection.
-     * @param dbConfig `QdrantLibArgs` instance specifying the configuration for the Qdrant database.
-     * @returns Promise that resolves with a new `QdrantVectorStore` instance.
-     */
-    static async fromExistingCollection(embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.ensureCollection();
-        return instance;
-    }
-}
-exports.QdrantVectorStore = QdrantVectorStore;
+__exportStar(require("@langchain/community/vectorstores/qdrant"), exports);

package/dist/vectorstores/qdrant.d.ts

@@ -1,95 +1 @@
-import { QdrantClient } from "@qdrant/js-client-rest";
-import type { Schemas as QdrantSchemas } from "@qdrant/js-client-rest";
-import { Embeddings } from "../embeddings/base.js";
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-/**
- * Interface for the arguments that can be passed to the
- * `QdrantVectorStore` constructor. It includes options for specifying a
- * `QdrantClient` instance, the URL and API key for a Qdrant database, and
- * the name and configuration for a collection.
- */
-export interface QdrantLibArgs {
-    client?: QdrantClient;
-    url?: string;
-    apiKey?: string;
-    collectionName?: string;
-    collectionConfig?: QdrantSchemas["CreateCollection"];
-}
-/**
- * Class that extends the `VectorStore` base class to interact with a
- * Qdrant database. It includes methods for adding documents and vectors
- * to the Qdrant database, searching for similar vectors, and ensuring the
- * existence of a collection in the database.
- */
-export declare class QdrantVectorStore extends VectorStore {
-    get lc_secrets(): {
-        [key: string]: string;
-    };
-    client: QdrantClient;
-    collectionName: string;
-    collectionConfig?: QdrantSchemas["CreateCollection"];
-    _vectorstoreType(): string;
-    constructor(embeddings: Embeddings, args: QdrantLibArgs);
-    /**
-     * Method to add documents to the Qdrant database. It generates vectors
-     * from the documents using the `Embeddings` instance and then adds the
-     * vectors to the database.
-     * @param documents Array of `Document` instances to be added to the Qdrant database.
-     * @returns Promise that resolves when the documents have been added to the database.
-     */
-    addDocuments(documents: Document[]): Promise<void>;
-    /**
-     * Method to add vectors to the Qdrant database. Each vector is associated
-     * with a document, which is stored as the payload for a point in the
-     * database.
-     * @param vectors Array of vectors to be added to the Qdrant database.
-     * @param documents Array of `Document` instances associated with the vectors.
-     * @returns Promise that resolves when the vectors have been added to the database.
-     */
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
-    /**
-     * Method to search for vectors in the Qdrant database that are similar to
-     * a given query vector. The search results include the score and payload
-     * (metadata and content) for each similar vector.
-     * @param query Query vector to search for similar vectors in the Qdrant database.
-     * @param k Optional number of similar vectors to return. If not specified, all similar vectors are returned.
-     * @param filter Optional filter to apply to the search results.
-     * @returns Promise that resolves with an array of tuples, where each tuple includes a `Document` instance and a score for a similar vector.
-     */
-    similaritySearchVectorWithScore(query: number[], k?: number, filter?: QdrantSchemas["Filter"]): Promise<[Document, number][]>;
-    /**
-     * Method to ensure the existence of a collection in the Qdrant database.
-     * If the collection does not exist, it is created.
-     * @returns Promise that resolves when the existence of the collection has been ensured.
-     */
-    ensureCollection(): Promise<void>;
-    /**
-     * Static method to create a `QdrantVectorStore` instance from texts. Each
-     * text is associated with metadata and converted to a `Document`
-     * instance, which is then added to the Qdrant database.
-     * @param texts Array of texts to be converted to `Document` instances and added to the Qdrant database.
-     * @param metadatas Array or single object of metadata to be associated with the texts.
-     * @param embeddings `Embeddings` instance used to generate vectors from the texts.
-     * @param dbConfig `QdrantLibArgs` instance specifying the configuration for the Qdrant database.
-     * @returns Promise that resolves with a new `QdrantVectorStore` instance.
-     */
-    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: QdrantLibArgs): Promise<QdrantVectorStore>;
-    /**
-     * Static method to create a `QdrantVectorStore` instance from `Document`
-     * instances. The documents are added to the Qdrant database.
-     * @param docs Array of `Document` instances to be added to the Qdrant database.
-     * @param embeddings `Embeddings` instance used to generate vectors from the documents.
-     * @param dbConfig `QdrantLibArgs` instance specifying the configuration for the Qdrant database.
-     * @returns Promise that resolves with a new `QdrantVectorStore` instance.
-     */
-    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: QdrantLibArgs): Promise<QdrantVectorStore>;
-    /**
-     * Static method to create a `QdrantVectorStore` instance from an existing
-     * collection in the Qdrant database.
-     * @param embeddings `Embeddings` instance used to generate vectors from the documents in the collection.
-     * @param dbConfig `QdrantLibArgs` instance specifying the configuration for the Qdrant database.
-     * @returns Promise that resolves with a new `QdrantVectorStore` instance.
-     */
-    static fromExistingCollection(embeddings: Embeddings, dbConfig: QdrantLibArgs): Promise<QdrantVectorStore>;
-}
+export * from "@langchain/community/vectorstores/qdrant";