langchain 0.0.165 → 0.0.167

package/dist/vectorstores/neo4j_vector.js

@@ -0,0 +1,548 @@
+import neo4j from "neo4j-driver";
+import * as uuid from "uuid";
+import { Document } from "../document.js";
+import { VectorStore } from "./base.js";
+const DEFAULT_SEARCH_TYPE = "vector";
+const DEFAULT_DISTANCE_STRATEGY = "cosine";
+export class Neo4jVectorStore extends VectorStore {
+    _vectorstoreType() {
+        return "neo4jvector";
+    }
+    constructor(embeddings, config) {
+        super(embeddings, config);
+        Object.defineProperty(this, "driver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "database", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "preDeleteCollection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "nodeLabel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embeddingNodeProperty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embeddingDimension", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "textNodeProperty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keywordIndexName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "indexName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retrievalQuery", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "searchType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "distanceStrategy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: DEFAULT_DISTANCE_STRATEGY
+        });
+    }
+    static async initialize(embeddings, config) {
+        const store = new Neo4jVectorStore(embeddings, config);
+        await store._initializeDriver(config);
+        await store._verifyConnectivity();
+        const { preDeleteCollection = false, nodeLabel = "Chunk", textNodeProperty = "text", embeddingNodeProperty = "embedding", keywordIndexName = "keyword", indexName = "vector", retrievalQuery = "", searchType = DEFAULT_SEARCH_TYPE, } = config;
+        store.embeddingDimension = (await embeddings.embedQuery("foo")).length;
+        store.preDeleteCollection = preDeleteCollection;
+        store.nodeLabel = nodeLabel;
+        store.textNodeProperty = textNodeProperty;
+        store.embeddingNodeProperty = embeddingNodeProperty;
+        store.keywordIndexName = keywordIndexName;
+        store.indexName = indexName;
+        store.retrievalQuery = retrievalQuery;
+        store.searchType = searchType;
+        if (store.preDeleteCollection) {
+            await store._dropIndex();
+        }
+        return store;
+    }
+    async _initializeDriver({ url, username, password, database = "neo4j", }) {
+        try {
+            this.driver = neo4j.driver(url, neo4j.auth.basic(username, password));
+            this.database = database;
+        }
+        catch (error) {
+            throw new Error("Could not create a Neo4j driver instance. Please check the connection details.");
+        }
+    }
+    async _verifyConnectivity() {
+        await this.driver.verifyAuthentication();
+    }
+    async close() {
+        await this.driver.close();
+    }
+    async _dropIndex() {
+        try {
+            await this.query(`
+        MATCH (n:\`${this.nodeLabel}\`)
+        CALL {
+          WITH n
+          DETACH DELETE n
+        }
+        IN TRANSACTIONS OF 10000 ROWS;
+      `);
+            await this.query(`DROP INDEX ${this.indexName}`);
+        }
+        catch (error) {
+            console.error("An error occurred while dropping the index:", error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async query(query, params = {}) {
+        const session = this.driver.session({ database: this.database });
+        const result = await session.run(query, params);
+        return toObjects(result.records);
+    }
+    static async fromTexts(texts, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    metadatas, embeddings, config) {
+        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 Neo4jVectorStore.fromDocuments(docs, embeddings, config);
+    }
+    static async fromDocuments(docs, embeddings, config) {
+        const { searchType = DEFAULT_SEARCH_TYPE, createIdIndex = true, textNodeProperties = [], } = config;
+        const store = await this.initialize(embeddings, config);
+        const embeddingDimension = await store.retrieveExistingIndex();
+        if (!embeddingDimension) {
+            await store.createNewIndex();
+        }
+        else if (store.embeddingDimension !== embeddingDimension) {
+            throw new Error(`Index with name "${store.indexName}" already exists. The provided embedding function and vector index dimensions do not match.
+        Embedding function dimension: ${store.embeddingDimension}
+        Vector index dimension: ${embeddingDimension}`);
+        }
+        if (searchType === "hybrid") {
+            const ftsNodeLabel = await store.retrieveExistingFtsIndex();
+            if (!ftsNodeLabel) {
+                await store.createNewKeywordIndex(textNodeProperties);
+            }
+            else {
+                if (ftsNodeLabel !== store.nodeLabel) {
+                    throw Error("Vector and keyword index don't index the same node label");
+                }
+            }
+        }
+        if (createIdIndex) {
+            await store.query(`CREATE CONSTRAINT IF NOT EXISTS FOR (n:${store.nodeLabel}) REQUIRE n.id IS UNIQUE;`);
+        }
+        await store.addDocuments(docs);
+        return store;
+    }
+    static async fromExistingIndex(embeddings, config) {
+        const { searchType = DEFAULT_SEARCH_TYPE, keywordIndexName = "keyword" } = config;
+        if (searchType === "hybrid" && !keywordIndexName) {
+            throw Error("keyword_index name has to be specified when using hybrid search option");
+        }
+        const store = await this.initialize(embeddings, config);
+        const embeddingDimension = await store.retrieveExistingIndex();
+        if (!embeddingDimension) {
+            throw Error("The specified vector index name does not exist. Make sure to check if you spelled it correctly");
+        }
+        if (store.embeddingDimension !== embeddingDimension) {
+            throw new Error(`The provided embedding function and vector index dimensions do not match.
+         Embedding function dimension: ${store.embeddingDimension}
+         Vector index dimension: ${embeddingDimension}`);
+        }
+        if (searchType === "hybrid") {
+            const ftsNodeLabel = await store.retrieveExistingFtsIndex();
+            if (!ftsNodeLabel) {
+                throw Error("The specified keyword index name does not exist. Make sure to check if you spelled it correctly");
+            }
+            else {
+                if (ftsNodeLabel !== store.nodeLabel) {
+                    throw Error("Vector and keyword index don't index the same node label");
+                }
+            }
+        }
+        return store;
+    }
+    static async fromExistingGraph(embeddings, config) {
+        const { textNodeProperties = [], embeddingNodeProperty, searchType = DEFAULT_SEARCH_TYPE, retrievalQuery = "", nodeLabel, } = config;
+        let _retrievalQuery = retrievalQuery;
+        if (textNodeProperties.length === 0) {
+            throw Error("Parameter `text_node_properties` must not be an empty array");
+        }
+        if (!retrievalQuery) {
+            _retrievalQuery = `
+        RETURN reduce(str='', k IN ${JSON.stringify(textNodeProperties)} |
+        str + '\\n' + k + ': ' + coalesce(node[k], '')) AS text,
+        node {.*, \`${embeddingNodeProperty}\`: Null, id: Null, ${textNodeProperties
+                .map((prop) => `\`${prop}\`: Null`)
+                .join(", ")} } AS metadata, score
+      `;
+        }
+        const store = await this.initialize(embeddings, {
+            ...config,
+            retrievalQuery: _retrievalQuery,
+        });
+        const embeddingDimension = await store.retrieveExistingIndex();
+        if (!embeddingDimension) {
+            await store.createNewIndex();
+        }
+        else if (store.embeddingDimension !== embeddingDimension) {
+            throw new Error(`Index with name ${store.indexName} already exists. The provided embedding function and vector index dimensions do not match.\nEmbedding function dimension: ${store.embeddingDimension}\nVector index dimension: ${embeddingDimension}`);
+        }
+        if (searchType === "hybrid") {
+            const ftsNodeLabel = await store.retrieveExistingFtsIndex(textNodeProperties);
+            if (!ftsNodeLabel) {
+                await store.createNewKeywordIndex(textNodeProperties);
+            }
+            else {
+                if (ftsNodeLabel !== store.nodeLabel) {
+                    throw Error("Vector and keyword index don't index the same node label");
+                }
+            }
+        }
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const fetchQuery = `
+        MATCH (n:\`${nodeLabel}\`)
+        WHERE n.${embeddingNodeProperty} IS null
+        AND any(k in $props WHERE n[k] IS NOT null)
+        RETURN elementId(n) AS id, reduce(str='', k IN $props |
+        str + '\\n' + k + ':' + coalesce(n[k], '')) AS text
+        LIMIT 1000
+      `;
+            const data = await store.query(fetchQuery, { props: textNodeProperties });
+            if (!data) {
+                continue;
+            }
+            const textEmbeddings = await embeddings.embedDocuments(data.map((el) => el.text));
+            const params = {
+                data: data.map((el, index) => ({
+                    id: el.id,
+                    embedding: textEmbeddings[index],
+                })),
+            };
+            await store.query(`
+        UNWIND $data AS row
+        MATCH (n:\`${nodeLabel}\`)
+        WHERE elementId(n) = row.id
+        CALL db.create.setVectorProperty(n, '${embeddingNodeProperty}', row.embedding)
+        YIELD node RETURN count(*)
+      `, params);
+            if (data.length < 1000) {
+                break;
+            }
+        }
+        return store;
+    }
+    async createNewIndex() {
+        const indexQuery = `
+      CALL db.index.vector.createNodeIndex(
+        $index_name,
+        $node_label,
+        $embedding_node_property,
+        toInteger($embedding_dimension),
+        $similarity_metric
+      )
+    `;
+        const parameters = {
+            index_name: this.indexName,
+            node_label: this.nodeLabel,
+            embedding_node_property: this.embeddingNodeProperty,
+            embedding_dimension: this.embeddingDimension,
+            similarity_metric: this.distanceStrategy,
+        };
+        await this.query(indexQuery, parameters);
+    }
+    async retrieveExistingIndex() {
+        let indexInformation = await this.query(`
+        SHOW INDEXES YIELD name, type, labelsOrTypes, properties, options
+        WHERE type = 'VECTOR' AND (name = $index_name
+        OR (labelsOrTypes[0] = $node_label AND
+        properties[0] = $embedding_node_property))
+        RETURN name, labelsOrTypes, properties, options
+      `, {
+            index_name: this.indexName,
+            node_label: this.nodeLabel,
+            embedding_node_property: this.embeddingNodeProperty,
+        });
+        if (indexInformation) {
+            indexInformation = this.sortByIndexName(indexInformation, this.indexName);
+            try {
+                const [index] = indexInformation;
+                const [labelOrType] = index.labelsOrTypes;
+                const [property] = index.properties;
+                this.indexName = index.name;
+                this.nodeLabel = labelOrType;
+                this.embeddingNodeProperty = property;
+                const embeddingDimension = index.options.indexConfig["vector.dimensions"];
+                return Number(embeddingDimension);
+            }
+            catch (error) {
+                return null;
+            }
+        }
+        return null;
+    }
+    async retrieveExistingFtsIndex(textNodeProperties = []) {
+        const indexInformation = await this.query(`
+      SHOW INDEXES YIELD name, type, labelsOrTypes, properties, options
+      WHERE type = 'FULLTEXT' AND (name = $keyword_index_name
+      OR (labelsOrTypes = [$node_label] AND
+      properties = $text_node_property))
+      RETURN name, labelsOrTypes, properties, options
+    `, {
+            keyword_index_name: this.keywordIndexName,
+            node_label: this.nodeLabel,
+            text_node_property: textNodeProperties.length > 0
+                ? textNodeProperties
+                : [this.textNodeProperty],
+        });
+        if (indexInformation) {
+            // Sort the index information by index name
+            const sortedIndexInformation = this.sortByIndexName(indexInformation, this.indexName);
+            try {
+                const [index] = sortedIndexInformation;
+                const [labelOrType] = index.labelsOrTypes;
+                const [property] = index.properties;
+                this.keywordIndexName = index.name;
+                this.textNodeProperty = property;
+                this.nodeLabel = labelOrType;
+                return labelOrType;
+            }
+            catch (error) {
+                return null;
+            }
+        }
+        return null;
+    }
+    async createNewKeywordIndex(textNodeProperties = []) {
+        const nodeProps = textNodeProperties.length > 0
+            ? textNodeProperties
+            : [this.textNodeProperty];
+        // Construct the Cypher query to create a new full text index
+        const ftsIndexQuery = `
+      CREATE FULLTEXT INDEX ${this.keywordIndexName}
+      FOR (n:\`${this.nodeLabel}\`) ON EACH
+      [${nodeProps.map((prop) => `n.\`${prop}\``).join(", ")}]
+    `;
+        await this.query(ftsIndexQuery);
+    }
+    sortByIndexName(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    values, indexName
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        return values.sort((a, b) => (a.index_name === indexName ? -1 : 0) -
+            (b.index_name === indexName ? -1 : 0));
+    }
+    async addVectors(vectors, documents, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    metadatas, ids) {
+        let _ids = ids;
+        let _metadatas = metadatas;
+        if (!_ids) {
+            _ids = documents.map(() => uuid.v1());
+        }
+        if (!metadatas) {
+            _metadatas = documents.map(() => ({}));
+        }
+        const importQuery = `
+      UNWIND $data AS row
+      CALL {
+        WITH row
+        MERGE (c:\`${this.nodeLabel}\` {id: row.id})
+        WITH c, row
+        CALL db.create.setVectorProperty(c, '${this.embeddingNodeProperty}', row.embedding)
+        YIELD node
+        SET c.\`${this.textNodeProperty}\` = row.text
+        SET c += row.metadata
+      } IN TRANSACTIONS OF 1000 ROWS
+    `;
+        const parameters = {
+            data: documents.map(({ pageContent, metadata }, index) => ({
+                text: pageContent,
+                metadata: _metadatas ? _metadatas[index] : metadata,
+                embedding: vectors[index],
+                id: _ids ? _ids[index] : null,
+            })),
+        };
+        await this.query(importQuery, parameters);
+        return _ids;
+    }
+    async addDocuments(documents) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+    }
+    async similaritySearch(query, k = 4) {
+        const embedding = await this.embeddings.embedQuery(query);
+        const results = await this.similaritySearchVectorWithScore(embedding, k, query);
+        return results.map((result) => result[0]);
+    }
+    async similaritySearchVectorWithScore(vector, k, query) {
+        const defaultRetrieval = `
+    RETURN node.${this.textNodeProperty} AS text, score,
+    node {.*, ${this.textNodeProperty}: Null,
+    ${this.embeddingNodeProperty}: Null, id: Null } AS metadata
+    `;
+        const retrievalQuery = this.retrievalQuery
+            ? this.retrievalQuery
+            : defaultRetrieval;
+        const readQuery = `${getSearchIndexQuery(this.searchType)} ${retrievalQuery}`;
+        const parameters = {
+            index: this.indexName,
+            k: Number(k),
+            embedding: vector,
+            keyword_index: this.keywordIndexName,
+            query,
+        };
+        const results = await this.query(readQuery, parameters);
+        if (results) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const docs = results.map((result) => [
+                new Document({
+                    pageContent: result.text,
+                    metadata: Object.fromEntries(Object.entries(result.metadata).filter(([_, v]) => v !== null)),
+                }),
+                result.score,
+            ]);
+            return docs;
+        }
+        return [];
+    }
+}
+function toObjects(records) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const recordValues = records.map((record) => {
+        const rObj = record.toObject();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const out = {};
+        Object.keys(rObj).forEach((key) => {
+            out[key] = itemIntToString(rObj[key]);
+        });
+        return out;
+    });
+    return recordValues;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function itemIntToString(item) {
+    if (neo4j.isInt(item))
+        return item.toString();
+    if (Array.isArray(item))
+        return item.map((ii) => itemIntToString(ii));
+    if (["number", "string", "boolean"].indexOf(typeof item) !== -1)
+        return item;
+    if (item === null)
+        return item;
+    if (typeof item === "object")
+        return objIntToString(item);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function objIntToString(obj) {
+    const entry = extractFromNeoObjects(obj);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let newObj = null;
+    if (Array.isArray(entry)) {
+        newObj = entry.map((item) => itemIntToString(item));
+    }
+    else if (entry !== null && typeof entry === "object") {
+        newObj = {};
+        Object.keys(entry).forEach((key) => {
+            newObj[key] = itemIntToString(entry[key]);
+        });
+    }
+    return newObj;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractFromNeoObjects(obj) {
+    if (
+    // eslint-disable-next-line
+    obj instanceof neo4j.types.Node ||
+        // eslint-disable-next-line
+        obj instanceof neo4j.types.Relationship) {
+        return obj.properties;
+        // eslint-disable-next-line
+    }
+    else if (obj instanceof neo4j.types.Path) {
+        // eslint-disable-next-line
+        return [].concat.apply([], extractPathForRows(obj));
+    }
+    return obj;
+}
+function extractPathForRows(path) {
+    let { segments } = path;
+    // Zero length path. No relationship, end === start
+    if (!Array.isArray(path.segments) || path.segments.length < 1) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        segments = [{ ...path, end: null }];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return segments.map((segment) => [
+        objIntToString(segment.start),
+        objIntToString(segment.relationship),
+        objIntToString(segment.end),
+    ].filter((part) => part !== null));
+}
+function getSearchIndexQuery(searchType) {
+    const typeToQueryMap = {
+        vector: "CALL db.index.vector.queryNodes($index, $k, $embedding) YIELD node, score",
+        hybrid: `
+          CALL {
+              CALL db.index.vector.queryNodes($index, $k, $embedding) YIELD node, score
+              RETURN node, score UNION
+              CALL db.index.fulltext.queryNodes($keyword_index, $query, {limit: $k}) YIELD node, score
+              WITH collect({node: node, score: score}) AS nodes, max(score) AS max
+              UNWIND nodes AS n
+              RETURN n.node AS node, (n.score / max) AS score
+          }
+          WITH node, max(score) AS score ORDER BY score DESC LIMIT toInteger($k)
+      `,
+    };
+    return typeToQueryMap[searchType];
+}

package/dist/vectorstores/supabase.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SupabaseVectorStore = void 0;
 const base_js_1 = require("./base.cjs");
 const document_js_1 = require("../document.cjs");
+const math_js_1 = require("../util/math.cjs");
 /**
  * Class for interacting with a Supabase database to store and manage
  * vectors.
@@ -103,14 +104,7 @@ class SupabaseVectorStore extends base_js_1.VectorStore {
             await this.client.from(this.tableName).delete().eq("id", id);
         }
     }
-    /**
-     * Performs a similarity search on the vector store.
-     * @param query The query vector.
-     * @param k The number of results to return.
-     * @param filter Optional filter to apply to the search.
-     * @returns A promise that resolves with the search results when the search is complete.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
+    async _searchSupabase(query, k, filter) {
         if (filter && this.filter) {
             throw new Error("cannot provide both `filter` and `this.filter`");
         }
@@ -135,6 +129,17 @@ class SupabaseVectorStore extends base_js_1.VectorStore {
         if (error) {
             throw new Error(`Error searching for documents: ${error.code} ${error.message} ${error.details}`);
         }
+        return searches;
+    }
+    /**
+     * Performs a similarity search on the vector store.
+     * @param query The query vector.
+     * @param k The number of results to return.
+     * @param filter Optional filter to apply to the search.
+     * @returns A promise that resolves with the search results when the search is complete.
+     */
+    async similaritySearchVectorWithScore(query, k, filter) {
+        const searches = await this._searchSupabase(query, k, filter);
         const result = searches.map((resp) => [
             new document_js_1.Document({
                 metadata: resp.metadata,
@@ -144,6 +149,30 @@ class SupabaseVectorStore extends base_js_1.VectorStore {
         ]);
         return result;
     }
+    /**
+     * Return documents selected using the maximal marginal relevance.
+     * Maximal marginal relevance optimizes for similarity to the query AND diversity
+     * among selected documents.
+     *
+     * @param {string} query - Text to look up documents similar to.
+     * @param {number} options.k - Number of documents to return.
+     * @param {number} options.fetchK=20- Number of documents to fetch before passing to the MMR algorithm.
+     * @param {number} options.lambda=0.5 - Number between 0 and 1 that determines the degree of diversity among the results,
+     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
+     * @param {SupabaseLibArgs} options.filter - Optional filter to apply to the search.
+     *
+     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
+     */
+    async maxMarginalRelevanceSearch(query, options) {
+        const queryEmbedding = await this.embeddings.embedQuery(query);
+        const searches = await this._searchSupabase(queryEmbedding, options.fetchK ?? 20, options.filter);
+        const embeddingList = searches.map((searchResp) => searchResp.embedding);
+        const mmrIndexes = (0, math_js_1.maximalMarginalRelevance)(queryEmbedding, embeddingList, options.lambda, options.k);
+        return mmrIndexes.map((idx) => new document_js_1.Document({
+            metadata: searches[idx].metadata,
+            pageContent: searches[idx].content,
+        }));
+    }
     /**
      * Creates a new SupabaseVectorStore instance from an array of texts.
      * @param texts The texts to create documents from.

package/dist/vectorstores/supabase.d.ts

@@ -1,11 +1,21 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 import type { PostgrestFilterBuilder } from "@supabase/postgrest-js";
-import { VectorStore } from "./base.js";
+import { MaxMarginalRelevanceSearchOptions, VectorStore } from "./base.js";
 import { Embeddings } from "../embeddings/base.js";
 import { Document } from "../document.js";
 export type SupabaseMetadata = Record<string, any>;
 export type SupabaseFilter = PostgrestFilterBuilder<any, any, any>;
 export type SupabaseFilterRPCCall = (rpcCall: SupabaseFilter) => SupabaseFilter;
+/**
+ * Interface for the response returned when searching embeddings.
+ */
+interface SearchEmbeddingsResponse {
+    id: number;
+    content: string;
+    metadata: object;
+    embedding: number[];
+    similarity: number;
+}
 /**
  * Interface for the arguments required to initialize a Supabase library.
  */
@@ -56,6 +66,7 @@ export declare class SupabaseVectorStore extends VectorStore {
     delete(params: {
         ids: string[] | number[];
     }): Promise<void>;
+    protected _searchSupabase(query: number[], k: number, filter?: this["FilterType"]): Promise<SearchEmbeddingsResponse[]>;
     /**
      * Performs a similarity search on the vector store.
      * @param query The query vector.
@@ -64,6 +75,21 @@ export declare class SupabaseVectorStore extends VectorStore {
      * @returns A promise that resolves with the search results when the search is complete.
      */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
+    /**
+     * Return documents selected using the maximal marginal relevance.
+     * Maximal marginal relevance optimizes for similarity to the query AND diversity
+     * among selected documents.
+     *
+     * @param {string} query - Text to look up documents similar to.
+     * @param {number} options.k - Number of documents to return.
+     * @param {number} options.fetchK=20- Number of documents to fetch before passing to the MMR algorithm.
+     * @param {number} options.lambda=0.5 - Number between 0 and 1 that determines the degree of diversity among the results,
+     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
+     * @param {SupabaseLibArgs} options.filter - Optional filter to apply to the search.
+     *
+     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
+     */
+    maxMarginalRelevanceSearch(query: string, options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>): Promise<Document[]>;
     /**
      * Creates a new SupabaseVectorStore instance from an array of texts.
      * @param texts The texts to create documents from.
@@ -89,3 +115,4 @@ export declare class SupabaseVectorStore extends VectorStore {
      */
     static fromExistingIndex(embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;
 }
+export {};