@getzep/zep-cloud 0.0.1-rc.1

package/examples/memory/memory_example.ts

@@ -0,0 +1,252 @@
+import { v4 as uuidv4 } from "uuid";
+import { CreateUserRequest, Message, NotFoundError } from "../../src/api";
+import { ZepClient } from "../../src";
+
+// @ts-ignore
+import { history } from "./chat_shoe_store_history";
+
+function sleep(ms: number) {
+    const date = Date.now();
+    let currentDate = 0;
+    do {
+        currentDate = Date.now();
+    } while (currentDate - date < ms);
+}
+
+async function main() {
+    const projectApiKey = process.env.ZEP_API_KEY;
+
+    const client = new ZepClient({
+        apiKey: projectApiKey,
+    });
+
+    // Create a user
+    const userId = uuidv4();
+    const userRequest: CreateUserRequest = {
+        userId: `amy${userId}`,
+        metadata: { role: "admin" },
+        email: "amy@acme.com",
+        firstName: "Amy",
+        lastName: "Wu",
+    };
+    const user = await client.user.add(userRequest);
+    console.debug("Created user ", user);
+
+    // Example session ID
+    const sessionID = uuidv4();
+
+    // Add session associated with the above user
+    try {
+        await client.memory.addSession({
+            sessionId: sessionID,
+            metadata: { foo: "bar" },
+            userId: user.userId,
+        });
+        console.debug("Adding new session ", sessionID);
+    } catch (error) {
+        console.debug("Got error:", error);
+    }
+
+    // Get session
+    try {
+        const session = await client.memory.getSession(sessionID);
+        console.debug("Retrieved session ", session);
+    } catch (error) {
+        console.debug("Got error:", error);
+    }
+
+    // Add memory. We could do this in a batch, but we'll do it one by one rather to
+    // ensure that summaries and other artifacts are generated correctly.
+    try {
+        for (const { role, role_type, content } of history) {
+            await client.memory.add(sessionID, {
+                messages: [{ role, roleType: role_type, content }],
+            });
+        }
+        console.debug("Added new memory for session ", sessionID);
+    } catch (error) {
+        console.debug("Got error:", error);
+    }
+
+    try {
+        // Synthesize a question from most recent messages.
+        // Useful for RAG apps.
+        // This is faster than using an LLM chain.
+        console.debug("\n---Synthesize a question from most recent messages");
+        const { question } = await client.memory.synthesizeQuestion(sessionID, { lastNMessages: 3 });
+        console.debug(`Question: ${question}`);
+    } catch (error) {
+        console.debug("Got error:", error);
+    }
+
+    try {
+        // Classify the session.
+        // Useful for semantic routing, filtering, and many other use cases.
+        console.debug("\n---Classify the session");
+        const classes = ["low spender <$50", "medium spender >=$50, <$100", "high spender >=$100", "unknown"];
+        const classification = await client.memory.classifySession(sessionID, {
+            name: "spender_category",
+            classes,
+            persist: true,
+        });
+        console.debug(`${classification.class} Classification Result: ${classification.name}`);
+    } catch (error) {
+        console.debug("Got error:", error);
+    }
+
+    console.log("Sleeping for 5 seconds to let background tasks complete...");
+    sleep(5000); // Sleep for 5 seconds
+    console.log("Done sleeping!");
+
+    // Get newly added memory
+    try {
+        console.debug("Getting memory for newly added memory with sessionid ", sessionID);
+        const memory = await client.memory.get(sessionID);
+        console.log("Memory: ", JSON.stringify(memory));
+        if (memory?.messages) {
+            memory.messages.forEach((message) => {
+                console.debug(JSON.stringify(message));
+            });
+        }
+    } catch (error) {
+        if (error instanceof NotFoundError) {
+            console.error("Session not found:", error.message);
+        } else {
+            console.error("Got error:", error);
+        }
+    }
+
+    // get session messages
+    let sessionMessages: Message[] = [];
+    try {
+        const sessionMessagesResult = await client.memory.getSessionMessages(sessionID, { limit: 10, cursor: 1 });
+        console.debug("Session messages: ", JSON.stringify(sessionMessagesResult));
+        if (sessionMessagesResult?.messages) {
+            sessionMessages = sessionMessagesResult.messages;
+        }
+    } catch (error) {
+        if (error instanceof NotFoundError) {
+            console.error("Session not found:", error.message);
+        } else {
+            console.error("Got error:", error);
+        }
+    }
+
+    const firstSessionsMessageId = sessionMessages[0].uuid;
+
+    // Update session message metadata
+    try {
+        const metadata = { metadata: { foo: "bar" } };
+        if (firstSessionsMessageId) {
+            const updatedMessage = await client.memory.updateMessageMetadata(sessionID, firstSessionsMessageId, {
+                metadata: metadata,
+            });
+            console.debug("Updated message: ", JSON.stringify(updatedMessage));
+        }
+    } catch (error) {
+        if (error instanceof NotFoundError) {
+            console.error("Session not found:", error.message);
+        } else {
+            console.error("Got error:", error);
+        }
+    }
+
+    // Get session message
+
+    try {
+        if (firstSessionsMessageId) {
+            const message = await client.memory.getSessionMessage(sessionID, firstSessionsMessageId);
+            console.debug("Session message: ", JSON.stringify(message));
+        }
+    } catch (error) {
+        if (error instanceof NotFoundError) {
+            console.error("Session not found:", error.message);
+        } else {
+            console.error("Got error:", error);
+        }
+    }
+
+    // Search messages in memory
+    try {
+        const searchText = "Name some books that are about dystopian futures.";
+        console.debug("Searching memory...", searchText);
+
+        const searchResults = await client.memory.search(sessionID, {
+            metadata: {
+                where: {
+                    and: [
+                        {
+                            jsonpath: '$.system.entities[*] ? (@.Label == "WORK_OF_ART")',
+                        },
+                        {
+                            jsonpath: '$.system.entities[*] ? (@.Name like_regex "^parable*" flag "i")',
+                        },
+                    ],
+                },
+            },
+            text: searchText,
+        });
+
+        searchResults.forEach((searchResult) => {
+            console.debug("Search Result: ", JSON.stringify(searchResult.message));
+            console.debug("Search Result Score: ", JSON.stringify(searchResult.score));
+        });
+    } catch (error) {
+        if (error instanceof NotFoundError) {
+            console.error("Session not found:", error.message);
+        } else {
+            console.error("Got error:", error);
+        }
+    }
+
+    // Search messages in memory with MMR and lambda=0.6
+    try {
+        const searchText = "Name some books that are about dystopian futures.";
+        console.debug("Searching memory with MMR...", searchText);
+
+        const searchResults = await client.memory.search(sessionID, {
+            text: searchText,
+            searchType: "mmr",
+            mmrLambda: 0.6,
+            limit: 3,
+        });
+
+        searchResults.forEach((searchResult) => {
+            console.debug("Search Result: ", JSON.stringify(searchResult.message));
+            console.debug("Search Result Score: ", JSON.stringify(searchResult.score));
+        });
+    } catch (error) {
+        if (error instanceof NotFoundError) {
+            console.error("Session not found:", error.message);
+        } else {
+            console.error("Got error:", error);
+        }
+    }
+
+    // Search summaries in memory with MMR and lambda=0.6
+    try {
+        const searchText = "Name some books that are about dystopian futures.";
+        console.debug("Searching summaries with MMR...", searchText);
+
+        const searchResults = await client.memory.search(sessionID, {
+            text: searchText,
+            searchScope: "summary",
+            searchType: "mmr",
+            mmrLambda: 0.6,
+            limit: 3,
+        });
+
+        searchResults.forEach((searchResult) => {
+            console.debug("Search Result: ", JSON.stringify(searchResult.summary));
+            console.debug("Search Result Score: ", JSON.stringify(searchResult.score));
+        });
+    } catch (error) {
+        if (error instanceof NotFoundError) {
+            console.error("Session not found:", error.message);
+        } else {
+            console.error("Got error:", error);
+        }
+    }
+}
+
+main();

package/examples/users/users.ts

@@ -0,0 +1,81 @@
+import { v4 as uuidv4 } from "uuid";
+import { ZepClient } from "../../src";
+import { CreateUserRequest, UpdateUserRequest } from "../../src/api";
+
+async function main() {
+    const projectApiKey = process.env.ZEP_API_KEY;
+
+    const client = new ZepClient({
+        apiKey: projectApiKey,
+    });
+
+    // Create multiple users
+    for (let i = 0; i < 3; i++) {
+        const userId = uuidv4();
+        const userRequest: CreateUserRequest = {
+            userId: userId,
+            email: `user${i}@example.com`,
+            firstName: `John${i}`,
+            lastName: `Doe${i}`,
+            metadata: { foo: "bar" },
+        };
+
+        try {
+            const user = await client.user.add(userRequest);
+            console.log(`Created user ${i + 1}: ${user.userId}`);
+        } catch (e) {
+            console.log(`Failed to create user ${i + 1}: ${e}`);
+        }
+    }
+
+    // Update the first user
+    const firstUser = (await client.user.listOrdered())?.users?.[0];
+    if (!firstUser) {
+        console.log("No user found");
+        return;
+    }
+    const userId = firstUser.userId;
+    const userRequest: UpdateUserRequest = {
+        email: "updated_user@example.com",
+        firstName: "UpdatedJohn",
+        lastName: "UpdatedDoe",
+        metadata: { foo: "updated_bar" },
+    };
+
+    try {
+        if (!userId) {
+            throw new Error("No user found");
+        }
+        const updatedUser = await client.user.update(userId, userRequest);
+        console.log(`Updated user: ${updatedUser}`);
+    } catch (e) {
+        console.log(`Failed to update user: ${e}`);
+    }
+
+    // Delete the second user
+    const userIdToDelete = (await client.user.listOrdered())?.users?.[1]?.userId;
+    try {
+        if (!userIdToDelete) {
+            throw new Error("No user found");
+        }
+        await client.user.delete(userIdToDelete);
+        console.log(`Deleted user: ${userIdToDelete}`);
+    } catch (e) {
+        console.log(`Failed to delete user: ${e}`);
+    }
+
+    // List all users
+    try {
+        console.log("All users:");
+        const usersResult = await client.user.listOrdered({ pageSize: 10, pageNumber: 1 });
+        if (usersResult && usersResult.users) {
+            for (const user of usersResult.users) {
+                console.log(user.userId);
+            }
+        }
+    } catch (e) {
+        console.log(`Failed to list users: ${e}`);
+    }
+}
+
+main();

package/index.d.ts

@@ -0,0 +1,4 @@
+export * as Zep from "./api";
+export { ZepClient } from "./wrapper";
+export { ZepEnvironment } from "./environments";
+export { ZepError, ZepTimeoutError } from "./errors";

package/index.js

@@ -0,0 +1,34 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZepTimeoutError = exports.ZepError = exports.ZepEnvironment = exports.ZepClient = exports.Zep = void 0;
+exports.Zep = __importStar(require("./api"));
+var wrapper_1 = require("./wrapper");
+Object.defineProperty(exports, "ZepClient", { enumerable: true, get: function () { return wrapper_1.ZepClient; } });
+var environments_1 = require("./environments");
+Object.defineProperty(exports, "ZepEnvironment", { enumerable: true, get: function () { return environments_1.ZepEnvironment; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ZepError", { enumerable: true, get: function () { return errors_1.ZepError; } });
+Object.defineProperty(exports, "ZepTimeoutError", { enumerable: true, get: function () { return errors_1.ZepTimeoutError; } });

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('jest').Config} */
+module.exports = {
+    preset: "ts-jest",
+    testEnvironment: "node",
+};

package/langchain/base_memory.d.ts

@@ -0,0 +1,58 @@
+import { BaseMemory, InputValues, OutputValues } from "@langchain/core/memory";
+import { BaseChatMessageHistory, BaseListChatMessageHistory } from "@langchain/core/chat_history";
+import { BaseMessage } from "@langchain/core/messages";
+/**
+ * Class for storing chat message history in-memory. It extends the
+ * BaseListChatMessageHistory class and provides methods to get, add, and
+ * clear messages.
+ */
+export declare class ChatMessageHistory extends BaseListChatMessageHistory {
+    lc_namespace: string[];
+    private messages;
+    constructor(messages?: BaseMessage[]);
+    /**
+     * Method to get all the messages stored in the ChatMessageHistory
+     * instance.
+     * @returns Array of stored BaseMessage instances.
+     */
+    getMessages(): Promise<BaseMessage[]>;
+    /**
+     * Method to add a new message to the ChatMessageHistory instance.
+     * @param message The BaseMessage instance to add.
+     * @returns A promise that resolves when the message has been added.
+     */
+    addMessage(message: BaseMessage): Promise<void>;
+    /**
+     * Method to clear all the messages from the ChatMessageHistory instance.
+     * @returns A promise that resolves when all messages have been cleared.
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Interface for the input parameters of the BaseChatMemory class.
+ */
+export interface BaseChatMemoryInput {
+    chatHistory?: BaseChatMessageHistory;
+    returnMessages?: boolean;
+    inputKey?: string;
+    outputKey?: string;
+}
+export declare abstract class BaseChatMemory extends BaseMemory {
+    chatHistory: BaseChatMessageHistory;
+    returnMessages: boolean;
+    inputKey?: string;
+    outputKey?: string;
+    constructor(fields?: BaseChatMemoryInput);
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
+    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
+    clear(): Promise<void>;
+}

package/langchain/base_memory.js

@@ -0,0 +1,92 @@
+"use strict";
+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.BaseChatMemory = exports.ChatMessageHistory = void 0;
+const memory_1 = require("@langchain/core/memory");
+const chat_history_1 = require("@langchain/core/chat_history");
+/**
+ * Class for storing chat message history in-memory. It extends the
+ * BaseListChatMessageHistory class and provides methods to get, add, and
+ * clear messages.
+ */
+class ChatMessageHistory extends chat_history_1.BaseListChatMessageHistory {
+    constructor(messages) {
+        // eslint-disable-next-line prefer-rest-params
+        super(...arguments);
+        this.lc_namespace = ["langchain", "stores", "message", "in_memory"];
+        this.messages = [];
+        this.messages = messages !== null && messages !== void 0 ? messages : [];
+    }
+    /**
+     * Method to get all the messages stored in the ChatMessageHistory
+     * instance.
+     * @returns Array of stored BaseMessage instances.
+     */
+    getMessages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.messages;
+        });
+    }
+    /**
+     * Method to add a new message to the ChatMessageHistory instance.
+     * @param message The BaseMessage instance to add.
+     * @returns A promise that resolves when the message has been added.
+     */
+    addMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.messages.push(message);
+        });
+    }
+    /**
+     * Method to clear all the messages from the ChatMessageHistory instance.
+     * @returns A promise that resolves when all messages have been cleared.
+     */
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.messages = [];
+        });
+    }
+}
+exports.ChatMessageHistory = ChatMessageHistory;
+class BaseChatMemory extends memory_1.BaseMemory {
+    constructor(fields) {
+        var _a, _b, _c, _d;
+        super();
+        this.returnMessages = false;
+        this.chatHistory = (_a = fields === null || fields === void 0 ? void 0 : fields.chatHistory) !== null && _a !== void 0 ? _a : new ChatMessageHistory();
+        this.returnMessages = (_b = fields === null || fields === void 0 ? void 0 : fields.returnMessages) !== null && _b !== void 0 ? _b : this.returnMessages;
+        this.inputKey = (_c = fields === null || fields === void 0 ? void 0 : fields.inputKey) !== null && _c !== void 0 ? _c : this.inputKey;
+        this.outputKey = (_d = fields === null || fields === void 0 ? void 0 : fields.outputKey) !== null && _d !== void 0 ? _d : this.outputKey;
+    }
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
+    saveContext(inputValues, outputValues) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this is purposefully done in sequence so they're saved in order
+            yield this.chatHistory.addUserMessage((0, memory_1.getInputValue)(inputValues, this.inputKey));
+            yield this.chatHistory.addAIChatMessage((0, memory_1.getOutputValue)(outputValues, this.outputKey));
+        });
+    }
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.chatHistory.clear();
+        });
+    }
+}
+exports.BaseChatMemory = BaseChatMemory;

package/langchain/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./message_history";
+export * from "./vector_store";
+export * from "./zep_memory";

package/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/langchain/memory/chat_memory.d.ts

@@ -0,0 +1,38 @@
+import { BaseMemory, InputValues, OutputValues } from "@langchain/core/memory";
+import { ZepChatMessageHistory } from "../message_history";
+import ZepClient from "../../zep-client";
+/**
+ * Interface for the input parameters of the BaseChatMemory class.
+ */
+export interface BaseChatMemoryInput {
+    chatHistory: ZepChatMessageHistory;
+    returnMessages?: boolean;
+    inputKey?: string;
+    outputKey?: string;
+    client: ZepClient;
+}
+/**
+ * Abstract class that provides a base for implementing different types of
+ * memory systems. It is designed to maintain the state of an application,
+ * specifically the history of a conversation. This class is typically
+ * extended by other classes to create specific types of memory systems.
+ */
+export declare abstract class BaseChatMemory extends BaseMemory {
+    chatHistory: ZepChatMessageHistory;
+    returnMessages: boolean;
+    inputKey?: string;
+    outputKey?: string;
+    protected constructor(fields: BaseChatMemoryInput);
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
+    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
+    clear(): Promise<void>;
+}

package/langchain/memory/chat_memory.js

@@ -0,0 +1,53 @@
+"use strict";
+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.BaseChatMemory = void 0;
+const memory_1 = require("@langchain/core/memory");
+/**
+ * Abstract class that provides a base for implementing different types of
+ * memory systems. It is designed to maintain the state of an application,
+ * specifically the history of a conversation. This class is typically
+ * extended by other classes to create specific types of memory systems.
+ */
+class BaseChatMemory extends memory_1.BaseMemory {
+    constructor(fields) {
+        var _a, _b, _c;
+        super();
+        this.returnMessages = false;
+        this.chatHistory = fields.chatHistory;
+        this.returnMessages = (_a = fields === null || fields === void 0 ? void 0 : fields.returnMessages) !== null && _a !== void 0 ? _a : this.returnMessages;
+        this.inputKey = (_b = fields === null || fields === void 0 ? void 0 : fields.inputKey) !== null && _b !== void 0 ? _b : this.inputKey;
+        this.outputKey = (_c = fields === null || fields === void 0 ? void 0 : fields.outputKey) !== null && _c !== void 0 ? _c : this.outputKey;
+    }
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
+    saveContext(inputValues, outputValues) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this is purposefully done in sequence so they're saved in order
+            yield this.chatHistory.addUserMessage((0, memory_1.getInputValue)(inputValues, this.inputKey));
+            yield this.chatHistory.addAIChatMessage((0, memory_1.getOutputValue)(outputValues, this.outputKey));
+        });
+    }
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.chatHistory.clear();
+        });
+    }
+}
+exports.BaseChatMemory = BaseChatMemory;