langchain 0.0.203 → 0.0.204-rc.1

package/dist/vectorstores/prisma.cjs

@@ -1,307 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrismaVectorStore = void 0;
-const base_js_1 = require("./base.cjs");
-const document_js_1 = require("../document.cjs");
-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: "<>",
+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);
 };
-/**
- * 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 base_js_1.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_js_1.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_js_1.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_js_1.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_js_1.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;
-    }
-}
-exports.PrismaVectorStore = PrismaVectorStore;
-Object.defineProperty(PrismaVectorStore, "IdColumn", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: IdColumnSymbol
-});
-Object.defineProperty(PrismaVectorStore, "ContentColumn", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: ContentColumnSymbol
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("@langchain/community/vectorstores/prisma"), exports);

package/dist/vectorstores/prisma.d.ts

@@ -1,180 +1 @@
-import { VectorStore } from "./base.js";
-import { Document } from "../document.js";
-import { type Embeddings } from "../embeddings/base.js";
-import { Callbacks } from "../callbacks/manager.js";
-declare const IdColumnSymbol: unique symbol;
-declare const ContentColumnSymbol: unique symbol;
-type ColumnSymbol = typeof IdColumnSymbol | typeof ContentColumnSymbol;
-declare type Value = unknown;
-declare type RawValue = Value | Sql;
-declare class Sql {
-    strings: string[];
-    constructor(rawStrings: ReadonlyArray<string>, rawValues: ReadonlyArray<RawValue>);
-}
-type PrismaNamespace = {
-    ModelName: Record<string, string>;
-    Sql: typeof Sql;
-    raw: (sql: string) => Sql;
-    join: (values: RawValue[], separator?: string, prefix?: string, suffix?: string) => Sql;
-    sql: (strings: ReadonlyArray<string>, ...values: RawValue[]) => Sql;
-};
-type PrismaClient = {
-    $queryRaw<T = unknown>(query: TemplateStringsArray | Sql, ...values: any[]): Promise<T>;
-    $executeRaw(query: TemplateStringsArray | Sql, ...values: any[]): Promise<any>;
-    $transaction<P extends Promise<any>[]>(arg: [...P]): Promise<any>;
-};
-type ObjectIntersect<A, B> = {
-    [P in keyof A & keyof B]: A[P] | B[P];
-};
-type ModelColumns<TModel extends Record<string, unknown>> = {
-    [K in keyof TModel]?: true | ColumnSymbol;
-};
-export type PrismaSqlFilter<TModel extends Record<string, unknown>> = {
-    [K in keyof TModel]?: {
-        equals?: TModel[K];
-        in?: TModel[K][];
-        isNull?: TModel[K];
-        isNotNull?: TModel[K];
-        like?: TModel[K];
-        lt?: TModel[K];
-        lte?: TModel[K];
-        gt?: TModel[K];
-        gte?: TModel[K];
-        not?: TModel[K];
-    };
-};
-type SimilarityModel<TModel extends Record<string, unknown> = Record<string, unknown>, TColumns extends ModelColumns<TModel> = ModelColumns<TModel>> = Pick<TModel, keyof ObjectIntersect<TModel, TColumns>> & {
-    _distance: number | null;
-};
-type DefaultPrismaVectorStore = PrismaVectorStore<Record<string, unknown>, string, ModelColumns<Record<string, unknown>>, PrismaSqlFilter<Record<string, unknown>>>;
-/**
- * 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.
- */
-export declare class PrismaVectorStore<TModel extends Record<string, unknown>, TModelName extends string, TSelectModel extends ModelColumns<TModel>, TFilterModel extends PrismaSqlFilter<TModel>> extends VectorStore {
-    protected tableName: string;
-    protected vectorColumnName: string;
-    protected selectColumns: string[];
-    filter?: TFilterModel;
-    idColumn: keyof TModel & string;
-    contentColumn: keyof TModel & string;
-    static IdColumn: typeof IdColumnSymbol;
-    static ContentColumn: typeof ContentColumnSymbol;
-    protected db: PrismaClient;
-    protected Prisma: PrismaNamespace;
-    _vectorstoreType(): string;
-    constructor(embeddings: Embeddings, config: {
-        db: PrismaClient;
-        prisma: PrismaNamespace;
-        tableName: TModelName;
-        vectorColumnName: string;
-        columns: TSelectModel;
-        filter?: TFilterModel;
-    });
-    /**
-     * Creates a new PrismaVectorStore with the specified model.
-     * @param db The PrismaClient instance.
-     * @returns An object with create, fromTexts, and fromDocuments methods.
-     */
-    static withModel<TModel extends Record<string, unknown>>(db: PrismaClient): {
-        create: <TPrisma extends PrismaNamespace, TColumns extends ModelColumns<TModel>, TFilters extends PrismaSqlFilter<TModel>>(embeddings: Embeddings, config: {
-            prisma: TPrisma;
-            tableName: keyof TPrisma["ModelName"] & string;
-            vectorColumnName: string;
-            columns: TColumns;
-            filter?: TFilters | undefined;
-        }) => PrismaVectorStore<TModel, keyof TPrisma["ModelName"] & string, TColumns, TFilters>;
-        fromTexts: <TPrisma_1 extends PrismaNamespace, TColumns_1 extends ModelColumns<TModel>>(texts: string[], metadatas: TModel[], embeddings: Embeddings, dbConfig: {
-            prisma: TPrisma_1;
-            tableName: keyof TPrisma_1["ModelName"] & string;
-            vectorColumnName: string;
-            columns: TColumns_1;
-        }) => Promise<DefaultPrismaVectorStore>;
-        fromDocuments: <TPrisma_2 extends PrismaNamespace, TColumns_2 extends ModelColumns<TModel>, TFilters_1 extends PrismaSqlFilter<TModel>>(docs: Document<TModel>[], embeddings: Embeddings, dbConfig: {
-            prisma: TPrisma_2;
-            tableName: keyof TPrisma_2["ModelName"] & string;
-            vectorColumnName: string;
-            columns: TColumns_2;
-        }) => Promise<PrismaVectorStore<TModel, keyof TPrisma_2["ModelName"] & string, TColumns_2, TFilters_1>>;
-    };
-    /**
-     * Adds the specified models to the store.
-     * @param models The models to add.
-     * @returns A promise that resolves when the models have been added.
-     */
-    addModels(models: TModel[]): Promise<void>;
-    /**
-     * Adds the specified documents to the store.
-     * @param documents The documents to add.
-     * @returns A promise that resolves when the documents have been added.
-     */
-    addDocuments(documents: Document<TModel>[]): Promise<void>;
-    /**
-     * 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.
-     */
-    addVectors(vectors: number[][], documents: Document<TModel>[]): Promise<void>;
-    /**
-     * 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.
-     */
-    similaritySearch(query: string, k?: number, _filter?: this["FilterType"] | undefined, // not used. here to make the interface compatible with the other stores
-    _callbacks?: Callbacks | undefined): Promise<Document<SimilarityModel<TModel, TSelectModel>>[]>;
-    /**
-     * 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.
-     */
-    similaritySearchWithScore(query: string, k?: number, filter?: TFilterModel, _callbacks?: Callbacks | undefined): Promise<[Document<Record<string, any>>, number][]>;
-    /**
-     * 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.
-     */
-    similaritySearchVectorWithScore(query: number[], k: number, filter?: TFilterModel): Promise<[Document<SimilarityModel<TModel, TSelectModel>>, number][]>;
-    buildSqlFilterStr(filter?: TFilterModel): Sql | null;
-    /**
-     * 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 fromTexts(texts: string[], metadatas: object[], embeddings: Embeddings, dbConfig: {
-        db: PrismaClient;
-        prisma: PrismaNamespace;
-        tableName: string;
-        vectorColumnName: string;
-        columns: ModelColumns<Record<string, unknown>>;
-    }): Promise<DefaultPrismaVectorStore>;
-    /**
-     * 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 fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: {
-        db: PrismaClient;
-        prisma: PrismaNamespace;
-        tableName: string;
-        vectorColumnName: string;
-        columns: ModelColumns<Record<string, unknown>>;
-    }): Promise<DefaultPrismaVectorStore>;
-}
-export {};
+export * from "@langchain/community/vectorstores/prisma";