@getzep/zep-cloud 0.0.1-rc.1

package/dist/langchain/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message_history"), exports);
+__exportStar(require("./vector_store"), exports);
+__exportStar(require("./zep_memory"), exports);

package/dist/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 "../";
+import { Zep } from "../";
+/**
+ * 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: Zep.MemoryGetRequestMemoryType;
+    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: Zep.MemoryGetRequestMemoryType;
+    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/dist/langchain/message_history.js

@@ -0,0 +1,109 @@
+"use strict";
+/* 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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZepChatMessageHistory = void 0;
+const messages_1 = require("@langchain/core/messages");
+const chat_history_1 = require("@langchain/core/chat_history");
+const api_1 = require("../api");
+const utils_1 = require("./utils");
+/**
+ * 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.
+ *
+ */
+class ZepChatMessageHistory extends chat_history_1.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.get(this.sessionId, { memoryType: this.memoryType });
+            }
+            catch (error) {
+                if (error instanceof api_1.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 [];
+            }
+            return [(0, utils_1.condenseZepMemoryIntoHumanMessage)(memory)];
+        });
+    }
+    addAIChatMessage(message, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addMessage(new messages_1.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");
+            }
+            yield this.client.memory.add(this.sessionId, {
+                messages: [
+                    {
+                        content: message.content,
+                        role: (_a = message.name) !== null && _a !== void 0 ? _a : message._getType(),
+                        roleType: (0, utils_1.getZepMessageRoleType)(message._getType()),
+                        metadata,
+                    },
+                ],
+            });
+        });
+    }
+    addUserMessage(message, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addMessage(new messages_1.HumanMessage({ content: message }, metadata));
+        });
+    }
+    clear() {
+        console.warn("Clearing memory", this.sessionId);
+        return Promise.resolve(undefined);
+    }
+}
+exports.ZepChatMessageHistory = ZepChatMessageHistory;

package/dist/langchain/utils.d.ts

@@ -0,0 +1,4 @@
+import { HumanMessage, MessageType } from "@langchain/core/messages";
+import { Memory, RoleType } from "../api";
+export declare const getZepMessageRoleType: (role: MessageType) => RoleType;
+export declare const condenseZepMemoryIntoHumanMessage: (memory: Memory) => HumanMessage;

package/dist/langchain/utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.condenseZepMemoryIntoHumanMessage = exports.getZepMessageRoleType = void 0;
+const messages_1 = require("@langchain/core/messages");
+const getZepMessageRoleType = (role) => {
+    switch (role) {
+        case "human":
+            return "user";
+        case "ai":
+            return "assistant";
+        case "system":
+            return "system";
+        case "function":
+            return "function";
+        case "tool":
+            return "tool";
+        default:
+            return "norole";
+    }
+};
+exports.getZepMessageRoleType = getZepMessageRoleType;
+const condenseZepMemoryIntoHumanMessage = (memory) => {
+    var _a;
+    let systemPrompt = "";
+    if (memory.facts) {
+        systemPrompt += memory.facts.join("\n");
+    }
+    // Extract summary, if present, and messages
+    if (memory.summary && ((_a = memory.summary) === null || _a === void 0 ? void 0 : _a.content)) {
+        systemPrompt += memory.summary.content;
+    }
+    let concatMessages = "";
+    if (memory.messages) {
+        concatMessages = memory.messages
+            .map((msg) => {
+            var _a;
+            return `${(_a = msg.role) !== null && _a !== void 0 ? _a : msg.roleType}: ${msg.content}`;
+        })
+            .join("\n");
+    }
+    return new messages_1.HumanMessage(systemPrompt + "\n" + concatMessages);
+};
+exports.condenseZepMemoryIntoHumanMessage = condenseZepMemoryIntoHumanMessage;

package/dist/langchain/vector_store.d.ts

@@ -0,0 +1,142 @@
+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 { ZepClient } from "../";
+/**
+ * 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;
+    collectionName: string;
+    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>;
+}