@getzep/zep-cloud 0.0.1-rc.1

package/esm/langchain/memory.d.ts

@@ -0,0 +1,79 @@
+import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
+import { BaseChatMemory, BaseChatMemoryInput } from "langchain/memory";
+import ZepClient from "../zep-client";
+export interface ZepMemoryInput extends BaseChatMemoryInput {
+    humanPrefix?: string;
+    aiPrefix?: string;
+    memoryKey?: string;
+    baseURL?: string;
+    sessionId: string;
+    apiKey: string;
+}
+/**
+ * Class used to manage the memory of a chat session, including loading
+ * and saving the chat history, and clearing the memory when needed. It
+ * uses the ZepClient to interact with the Zep service for managing the
+ * chat session's memory.
+ * @example
+ * ```typescript
+ * const sessionId = randomUUID();
+ *
+ * // Initialize ZepMemory with session ID, base URL, and API key
+ * const memory = new ZepMemory({
+ *   sessionId,
+ *   apiKey: "change_this_key",
+ * });
+ *
+ * // Create a ChatOpenAI model instance with specific parameters
+ * const model = new ChatOpenAI({
+ *   modelName: "gpt-3.5-turbo",
+ *   temperature: 0,
+ * });
+ *
+ * // Create a ConversationChain with the model and memory
+ * const chain = new ConversationChain({ llm: model, memory });
+ *
+ * // Example of calling the chain with an input
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Follow-up call to the chain to demonstrate memory usage
+ * const res2 = await chain.call({ input: "What did I just say my name was?" });
+ * console.log({ res2 });
+ *
+ * // Output the session ID and the current state of memory
+ * console.log("Session ID: ", sessionId);
+ * console.log("Memory: ", await memory.loadMemoryVariables({}));
+ *
+ * ```
+ */
+export declare class ZepMemory extends BaseChatMemory implements ZepMemoryInput {
+    humanPrefix: string;
+    aiPrefix: string;
+    memoryKey: string;
+    apiKey: string;
+    sessionId: string;
+    zepClientPromise: Promise<ZepClient>;
+    private readonly zepInitFailMsg;
+    constructor(fields: ZepMemoryInput);
+    get memoryKeys(): string[];
+    /**
+     * Method that retrieves the chat history from the Zep service and formats
+     * it into a list of messages.
+     * @param values Input values for the method.
+     * @returns Promise that resolves with the chat history formatted into a list of messages.
+     */
+    loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;
+    /**
+     * Method that saves the input and output messages to the Zep service.
+     * @param inputValues Input messages to be saved.
+     * @param outputValues Output messages to be saved.
+     * @returns Promise that resolves when the messages have been saved.
+     */
+    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+    /**
+     * Method that deletes the chat history from the Zep service.
+     * @returns Promise that resolves when the chat history has been deleted.
+     */
+    clear(): Promise<void>;
+}

package/esm/langchain/memory.js

@@ -0,0 +1,205 @@
+/* eslint import/no-extraneous-dependencies: 0 */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getInputValue, getOutputValue, } from "@langchain/core/memory";
+import { AIMessage, ChatMessage, getBufferString, HumanMessage, SystemMessage, } from "@langchain/core/messages";
+import { BaseChatMemory } from "langchain/memory";
+import ZepClient from "../zep-client";
+import { Memory } from "../memory_models";
+import { NotFoundError } from "../errors";
+import { Message } from "../message_models";
+/**
+ * Class used to manage the memory of a chat session, including loading
+ * and saving the chat history, and clearing the memory when needed. It
+ * uses the ZepClient to interact with the Zep service for managing the
+ * chat session's memory.
+ * @example
+ * ```typescript
+ * const sessionId = randomUUID();
+ *
+ * // Initialize ZepMemory with session ID, base URL, and API key
+ * const memory = new ZepMemory({
+ *   sessionId,
+ *   apiKey: "change_this_key",
+ * });
+ *
+ * // Create a ChatOpenAI model instance with specific parameters
+ * const model = new ChatOpenAI({
+ *   modelName: "gpt-3.5-turbo",
+ *   temperature: 0,
+ * });
+ *
+ * // Create a ConversationChain with the model and memory
+ * const chain = new ConversationChain({ llm: model, memory });
+ *
+ * // Example of calling the chain with an input
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Follow-up call to the chain to demonstrate memory usage
+ * const res2 = await chain.call({ input: "What did I just say my name was?" });
+ * console.log({ res2 });
+ *
+ * // Output the session ID and the current state of memory
+ * console.log("Session ID: ", sessionId);
+ * console.log("Memory: ", await memory.loadMemoryVariables({}));
+ *
+ * ```
+ */
+export class ZepMemory extends BaseChatMemory {
+    constructor(fields) {
+        var _a, _b, _c, _d;
+        super({
+            returnMessages: (_a = fields === null || fields === void 0 ? void 0 : fields.returnMessages) !== null && _a !== void 0 ? _a : false,
+            inputKey: fields === null || fields === void 0 ? void 0 : fields.inputKey,
+            outputKey: fields === null || fields === void 0 ? void 0 : fields.outputKey,
+        });
+        this.humanPrefix = "Human";
+        this.aiPrefix = "AI";
+        this.memoryKey = "history";
+        this.zepInitFailMsg = "ZepClient is not initialized";
+        this.humanPrefix = (_b = fields.humanPrefix) !== null && _b !== void 0 ? _b : this.humanPrefix;
+        this.aiPrefix = (_c = fields.aiPrefix) !== null && _c !== void 0 ? _c : this.aiPrefix;
+        this.memoryKey = (_d = fields.memoryKey) !== null && _d !== void 0 ? _d : this.memoryKey;
+        this.apiKey = fields.apiKey;
+        this.sessionId = fields.sessionId;
+        this.zepClientPromise = ZepClient.init(fields.apiKey, fields.baseURL);
+    }
+    get memoryKeys() {
+        return [this.memoryKey];
+    }
+    /**
+     * Method that retrieves the chat history from the Zep service and formats
+     * it into a list of messages.
+     * @param values Input values for the method.
+     * @returns Promise that resolves with the chat history formatted into a list of messages.
+     */
+    loadMemoryVariables(values) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            // use either lastN provided by developer or undefined to use the
+            // server preset.
+            // Wait for ZepClient to be initialized
+            const zepClient = yield this.zepClientPromise;
+            if (!zepClient) {
+                throw new Error(this.zepInitFailMsg);
+            }
+            const memoryType = (_a = values.memoryType) !== null && _a !== void 0 ? _a : "perpetual";
+            let memory = null;
+            try {
+                memory = yield zepClient.memory.getMemory(this.sessionId, memoryType);
+            }
+            catch (error) {
+                if (error instanceof NotFoundError) {
+                    return this.returnMessages
+                        ? { [this.memoryKey]: [] }
+                        : { [this.memoryKey]: "" };
+                }
+                throw error;
+            }
+            let messages = [];
+            if (memory) {
+                messages.push(new SystemMessage(memory.facts.join("\n")));
+                if ((_b = memory.summary) === null || _b === void 0 ? void 0 : _b.content) {
+                    messages.push(new SystemMessage(memory.summary.content));
+                }
+                messages = messages.concat(memory.messages.map((message) => {
+                    const { content, role_type, role } = message;
+                    if (role_type === "user") {
+                        return new HumanMessage(content);
+                    }
+                    if (role_type === "assistant") {
+                        return new AIMessage(content);
+                    }
+                    // default to generic ChatMessage
+                    return new ChatMessage(content, role);
+                }));
+            }
+            if (this.returnMessages) {
+                return {
+                    [this.memoryKey]: messages,
+                };
+            }
+            return {
+                [this.memoryKey]: getBufferString(messages, this.humanPrefix, this.aiPrefix),
+            };
+        });
+    }
+    /**
+     * Method that saves the input and output messages to the Zep service.
+     * @param inputValues Input messages to be saved.
+     * @param outputValues Output messages to be saved.
+     * @returns Promise that resolves when the messages have been saved.
+     */
+    saveContext(inputValues, outputValues) {
+        const _super = Object.create(null, {
+            saveContext: { get: () => super.saveContext }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const input = getInputValue(inputValues, this.inputKey);
+            const output = getOutputValue(outputValues, this.outputKey);
+            // Create new Memory and Message instances
+            const memory = new Memory({
+                messages: [
+                    new Message({
+                        role: this.humanPrefix,
+                        role_type: "user",
+                        content: `${input}`,
+                    }),
+                    new Message({
+                        role: this.aiPrefix,
+                        role_type: "assistant",
+                        content: `${output}`,
+                    }),
+                ],
+            });
+            // Wait for ZepClient to be initialized
+            const zepClient = yield this.zepClientPromise;
+            if (!zepClient) {
+                throw new Error(this.zepInitFailMsg);
+            }
+            // Add the new memory to the session using the ZepClient
+            if (this.sessionId) {
+                try {
+                    yield zepClient.memory.addMemory(this.sessionId, memory);
+                }
+                catch (error) {
+                    console.error("Error adding memory: ", error);
+                }
+            }
+            // Call the superclass's saveContext method
+            yield _super.saveContext.call(this, inputValues, outputValues);
+        });
+    }
+    /**
+     * Method that deletes the chat history from the Zep service.
+     * @returns Promise that resolves when the chat history has been deleted.
+     */
+    clear() {
+        const _super = Object.create(null, {
+            clear: { get: () => super.clear }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            // Wait for ZepClient to be initialized
+            const zepClient = yield this.zepClientPromise;
+            if (!zepClient) {
+                throw new Error(this.zepInitFailMsg);
+            }
+            try {
+                yield zepClient.memory.deleteMemory(this.sessionId);
+            }
+            catch (error) {
+                console.error("Error deleting session: ", error);
+            }
+            // Clear the superclass's chat history
+            yield _super.clear.call(this);
+        });
+    }
+}

package/esm/langchain/message_history.d.ts

@@ -0,0 +1,39 @@
+import { BaseMessage } from "@langchain/core/messages";
+import { BaseChatMessageHistory } from "@langchain/core/chat_history";
+import ZepClient from "../zep-client";
+import type { MemoryType } from "../interfaces";
+/**
+ * Interface defining the structure of the input data for the ZepMemory
+ * class. It includes properties like humanPrefix, aiPrefix, memoryKey,
+ * baseURL, sessionId, and apiKey.
+ */
+interface ZepMemoryInput {
+    sessionId: string;
+    client: ZepClient;
+    memoryType: MemoryType;
+    humanPrefix?: string;
+    aiPrefix?: string;
+}
+/**
+ * Class used to manage the memory of a chat session, including loading
+ * and saving the chat history, and clearing the memory when needed. It
+ * uses the ZepClient to interact with the Zep service for managing the
+ * chat session's memory.
+ *
+ */
+export declare class ZepChatMessageHistory extends BaseChatMessageHistory implements ZepMemoryInput {
+    lc_namespace: string[];
+    sessionId: string;
+    client: ZepClient;
+    memoryType: MemoryType;
+    humanPrefix: string;
+    aiPrefix: string;
+    constructor(fields: ZepMemoryInput);
+    private getMemory;
+    getMessages(): Promise<BaseMessage[]>;
+    addAIChatMessage(message: string, metadata?: any): Promise<void>;
+    addMessage(message: BaseMessage, metadata?: any): Promise<void>;
+    addUserMessage(message: string, metadata?: any): Promise<void>;
+    clear(): Promise<void>;
+}
+export {};

package/esm/langchain/message_history.js

@@ -0,0 +1,125 @@
+/* eslint import/no-extraneous-dependencies: 0 */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AIMessage, HumanMessage, SystemMessage, } from "@langchain/core/messages";
+import { BaseChatMessageHistory } from "@langchain/core/chat_history";
+import { Memory } from "../memory_models";
+import { NotFoundError } from "../errors";
+import { getZepMessageRoleType, Message } from "../message_models";
+/**
+ * Class used to manage the memory of a chat session, including loading
+ * and saving the chat history, and clearing the memory when needed. It
+ * uses the ZepClient to interact with the Zep service for managing the
+ * chat session's memory.
+ *
+ */
+export class ZepChatMessageHistory extends BaseChatMessageHistory {
+    constructor(fields) {
+        super();
+        this.lc_namespace = [];
+        this.humanPrefix = "human";
+        this.aiPrefix = "ai";
+        this.sessionId = fields.sessionId;
+        this.memoryType = fields.memoryType;
+        this.client = fields.client;
+        if (fields.humanPrefix) {
+            this.humanPrefix = fields.humanPrefix;
+        }
+        if (fields.aiPrefix) {
+            this.aiPrefix = fields.aiPrefix;
+        }
+    }
+    getMemory() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.client.memory.getMemory(this.sessionId, this.memoryType);
+            }
+            catch (error) {
+                if (error instanceof NotFoundError) {
+                    console.warn(`Session ${this.sessionId} not found in Zep. Returning None`);
+                }
+                else {
+                    console.error("Error getting memory: ", error);
+                }
+                return null;
+            }
+        });
+    }
+    getMessages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memory = yield this.getMemory();
+            if (!memory) {
+                return [];
+            }
+            const messages = [];
+            // Extract facts
+            messages.push(new SystemMessage(memory.facts.join("\n")));
+            // Extract summary, if present, and messages
+            if (memory.summary && memory.summary.content.length > 0) {
+                messages.push(new SystemMessage(memory.summary.content));
+            }
+            if (memory.messages) {
+                messages.push(...memory.messages.map((msg) => {
+                    const metadata = {
+                        uuid: msg.uuid,
+                        created_at: msg.created_at,
+                        token_count: msg.token_count,
+                        metadata: msg.metadata,
+                    };
+                    if (msg.role_type === "assistant") {
+                        return new AIMessage(msg.content, metadata);
+                    }
+                    return new HumanMessage(msg.content, metadata);
+                }));
+            }
+            return messages;
+        });
+    }
+    addAIChatMessage(message, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addMessage(new AIMessage({ content: message }), metadata);
+        });
+    }
+    addMessage(message, metadata) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const messageToSave = message;
+            if (message._getType() === "ai") {
+                messageToSave.name = this.aiPrefix;
+            }
+            else if (message._getType() === "human") {
+                messageToSave.name = this.humanPrefix;
+            }
+            if (message.content === null) {
+                throw new Error("Message content cannot be null");
+            }
+            if (Array.isArray(message.content)) {
+                throw new Error("Message content cannot be a list");
+            }
+            const zepMessage = new Message({
+                content: message.content,
+                role: (_a = message.name) !== null && _a !== void 0 ? _a : message._getType(),
+                role_type: getZepMessageRoleType(message._getType()),
+                metadata,
+            });
+            const zepMemory = new Memory({ messages: [zepMessage] });
+            yield this.client.memory.addMemory(this.sessionId, zepMemory);
+        });
+    }
+    addUserMessage(message, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addMessage(new HumanMessage({ content: message }, metadata));
+        });
+    }
+    clear() {
+        console.warn("Clearing memory", this.sessionId);
+        return Promise.resolve(undefined);
+    }
+}

package/esm/langchain/utils.d.ts

@@ -0,0 +1,12 @@
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { Document } from "@langchain/core/documents";
+/**
+ * Formats a document using a given prompt template.
+ *
+ * @async
+ * @param {Document} document - The document to format.
+ * @param {BasePromptTemplate} prompt - The prompt template to use for formatting.
+ * @returns {Promise<string>} A Promise that resolves to the formatted document as a string.
+ * @throws {Error} If the document is missing required metadata variables specified in the prompt template.
+ */
+export declare const formatDocument: (document: Document, prompt: BasePromptTemplate) => Promise<string>;

package/esm/langchain/utils.js

@@ -0,0 +1,37 @@
+/* eslint import/no-extraneous-dependencies: 0 */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/**
+ * Formats a document using a given prompt template.
+ *
+ * @async
+ * @param {Document} document - The document to format.
+ * @param {BasePromptTemplate} prompt - The prompt template to use for formatting.
+ * @returns {Promise<string>} A Promise that resolves to the formatted document as a string.
+ * @throws {Error} If the document is missing required metadata variables specified in the prompt template.
+ */
+export const formatDocument = (document, prompt) => __awaiter(void 0, void 0, void 0, function* () {
+    const baseInfo = Object.assign({ pageContent: document.pageContent }, document.metadata);
+    const variables = new Set(prompt.inputVariables);
+    const requiredMetadata = new Set(prompt.inputVariables
+        .map((v) => (v !== "pageContent" ? v : null))
+        .filter((v) => v !== null));
+    const missingMetadata = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (const variable of variables) {
+        if (!(variable in baseInfo) && variable !== "pageContent") {
+            missingMetadata.push(variable);
+        }
+    }
+    if (missingMetadata.length) {
+        throw new Error(`Document prompt requires documents to have metadata variables: ${JSON.stringify(requiredMetadata)}. Received document with missing metadata: ${JSON.stringify(missingMetadata)}`);
+    }
+    return prompt.format(baseInfo);
+});

package/esm/langchain/vector_store.d.ts

@@ -0,0 +1,143 @@
+import type { EmbeddingsInterface } from "@langchain/core/embeddings";
+import { MaxMarginalRelevanceSearchOptions, VectorStore } from "@langchain/core/vectorstores";
+import { Document } from "@langchain/core/documents";
+import { Callbacks } from "@langchain/core/callbacks/manager";
+import DocumentCollection from "../document_collection";
+import ZepClient from "../zep-client";
+/**
+ * Interface for the configuration options for a ZepVectorStore instance.
+ */
+export interface IZepConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    client?: ZepClient;
+    collectionName: string;
+    description?: string;
+    metadata?: Record<string, never>;
+}
+/**
+ * Interface for the parameters required to delete documents from a
+ * ZepVectorStore instance.
+ */
+export interface IZepDeleteParams {
+    uuids: string[];
+}
+/**
+ * ZepVectorStore is a VectorStore implementation
+ * that uses the Zep long-term memory store as a backend.
+ *
+ * If the collection does not exist, it will be created automatically.
+ *
+ * Requires `zep-js` to be installed:
+ * ```bash
+ * npm install @getzep/zep-js
+ * ```
+ *
+ * @property {ZepClient} client - The ZepClient instance used to interact with Zep's API.
+ * @property {Promise<void>} initPromise - A promise that resolves
+ * when the collection is initialized.
+ * @property {DocumentCollection} collection - The Zep document collection.
+ */
+export declare class ZepVectorStore extends VectorStore {
+    client: ZepClient;
+    collection: DocumentCollection;
+    private readonly initPromise;
+    constructor(embeddings: EmbeddingsInterface, args: IZepConfig);
+    /**
+     * Initializes the document collection. If the collection does not exist, it creates a new one.
+     *
+     * @param {IZepConfig} args - The configuration object for the Zep API.
+     */
+    private initCollection;
+    /**
+     * Creates a new document collection.
+     *
+     * @param {IZepConfig} args - The configuration object for the Zep API.
+     */
+    private createCollection;
+    /**
+     * Adds vectors and corresponding documents to the collection.
+     *
+     * @param {number[][]} vectors - The vectors to add.
+     * @param {Document[]} documents - The corresponding documents to add.
+     * @returns {Promise<string[]>} - A promise that resolves with the UUIDs of the added documents.
+     */
+    addVectors(vectors: number[][], documents: Document[]): Promise<string[]>;
+    /**
+     * Adds documents to the collection. The documents are first embedded into vectors
+     * using the provided embedding model.
+     *
+     * @param {Document[]} documents - The documents to add.
+     * @returns {Promise<string[]>} - A promise that resolves with the UUIDs of the added documents.
+     */
+    addDocuments(documents: Document[]): Promise<string[]>;
+    _vectorstoreType(): string;
+    /**
+     * Deletes documents from the collection.
+     *
+     * @param {IZepDeleteParams} params - The list of Zep document UUIDs to delete.
+     * @returns {Promise<void>}
+     */
+    delete(params: IZepDeleteParams): Promise<void>;
+    /**
+     * Performs a similarity search in the collection and returns the results with their scores.
+     *
+     * @param {number[]} query - The query vector.
+     * @param {number} k - The number of results to return.
+     * @param {Record<string, unknown>} filter - The filter to apply to the search. Zep only supports Record<string, unknown> as filter.
+     * @returns {Promise<[Document, number][]>} - A promise that resolves with the search results and their scores.
+     */
+    similaritySearchVectorWithScore(query: number[], k: number, filter?: Record<string, unknown> | undefined): Promise<[Document, number][]>;
+    _similaritySearchWithScore(query: string, k: number, filter?: Record<string, unknown> | undefined): Promise<[Document, number][]>;
+    similaritySearchWithScore(query: string, k?: number, filter?: Record<string, unknown> | undefined, _callbacks?: undefined): Promise<[Document, number][]>;
+    /**
+     * Performs a similarity search on the Zep collection.
+     *
+     * @param {string} query - The query string to search for.
+     * @param {number} [k=4] - The number of results to return. Defaults to 4.
+     * @param {this["FilterType"] | undefined} [filter=undefined] - An optional set of JSONPath filters to apply to the search.
+     * @param {Callbacks | undefined} [_callbacks=undefined] - Optional callbacks. Currently not implemented.
+     * @returns {Promise<Document[]>} - A promise that resolves to an array of Documents that are similar to the query.
+     *
+     * @async
+     */
+    similaritySearch(query: string, k?: number, filter?: this["FilterType"] | undefined, _callbacks?: Callbacks | undefined): Promise<Document[]>;
+    /**
+     * 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 options
+     * @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 {Record<string, any>} options.filter - Optional Zep JSONPath query to pre-filter on document metadata field
+     *
+     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
+     */
+    maxMarginalRelevanceSearch(query: string, options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>): Promise<Document[]>;
+    static init(zepConfig: IZepConfig): Promise<ZepVectorStore>;
+    /**
+     * Creates a new ZepVectorStore instance from an array of texts. Each text is converted into a Document and added to the collection.
+     *
+     * @param {string[]} texts - The texts to convert into Documents.
+     * @param {object[] | object} metadatas - The metadata to associate with each Document.
+     * If an array is provided, each element is associated with the corresponding Document.
+     * If an object is provided, it is associated with all Documents.
+     * @param {Embeddings} embeddings - The embeddings to use for vectorizing the texts.
+     * @param {IZepConfig} zepConfig - The configuration object for the Zep API.
+     * @returns {Promise<ZepVectorStore>} - A promise that resolves with the new ZepVectorStore instance.
+     */
+    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: EmbeddingsInterface, zepConfig: IZepConfig): Promise<ZepVectorStore>;
+    /**
+     * Creates a new ZepVectorStore instance from an array of Documents. Each Document is added to a Zep collection.
+     *
+     * @param {Document[]} docs - The Documents to add.
+     * @param {Embeddings} embeddings - The embeddings to use for vectorizing the Document contents.
+     * @param {IZepConfig} zepConfig - The configuration object for the Zep API.
+     * @returns {Promise<ZepVectorStore>} - A promise that resolves with the new ZepVectorStore instance.
+     */
+    static fromDocuments(docs: Document[], embeddings: EmbeddingsInterface, zepConfig: IZepConfig): Promise<ZepVectorStore>;
+}