reference.md

Reference

Document

client.document.listCollections() -> Zep.ApidataDocumentCollection[][]

📝 Description

Returns a list of all DocumentCollections.

🔌 Usage

await client.document.listCollections();

⚙️ Parameters

requestOptions: Document.RequestOptions

client.document.getCollection(collectionName) -> Zep.ApidataDocumentCollection

📝 Description

Returns a DocumentCollection if it exists.

🔌 Usage

await client.document.getCollection("collectionName");

⚙️ Parameters

collectionName: string — Name of the Document Collection

requestOptions: Document.RequestOptions

client.document.addCollection(collectionName, { ...params }) -> Zep.SuccessResponse

📝 Description

If a collection with the same name already exists, an error will be returned.

🔌 Usage

await client.document.addCollection("collectionName");

⚙️ Parameters

collectionName: string — Name of the Document Collection

request: Zep.CreateDocumentCollectionRequest

requestOptions: Document.RequestOptions

client.document.deleteCollection(collectionName) -> Zep.SuccessResponse

📝 Description

If a collection with the same name already exists, it will be overwritten.

🔌 Usage

await client.document.deleteCollection("collectionName");

⚙️ Parameters

collectionName: string — Name of the Document Collection

requestOptions: Document.RequestOptions

client.document.updateCollection(collectionName, { ...params }) -> Zep.SuccessResponse

📝 Description

Updates a DocumentCollection

🔌 Usage

await client.document.updateCollection("collectionName");

⚙️ Parameters

collectionName: string — Name of the Document Collection

request: Zep.UpdateDocumentCollectionRequest

requestOptions: Document.RequestOptions

client.document.addDocuments(collectionName, { ...params }) -> string[][]

📝 Description

Creates Documents in a specified DocumentCollection and returns their UUIDs.

🔌 Usage

await client.document.addDocuments("collectionName", [
    {
        content: "content",
    },
]);

⚙️ Parameters

collectionName: string — Name of the Document Collection

request: Zep.CreateDocumentRequest[]

requestOptions: Document.RequestOptions

client.document.batchDeleteDocuments(collectionName, { ...params }) -> Zep.SuccessResponse

📝 Description

Deletes specified Documents from a DocumentCollection.

🔌 Usage

await client.document.batchDeleteDocuments("collectionName", ["string"]);

⚙️ Parameters

collectionName: string — Name of the Document Collection

request: string[]

requestOptions: Document.RequestOptions

client.document.batchGetDocuments(collectionName, { ...params }) -> Zep.ApidataDocument[][]

📝 Description

Returns Documents from a DocumentCollection specified by UUID or ID.

🔌 Usage

await client.document.batchGetDocuments("collectionName");

⚙️ Parameters

collectionName: string — Name of the Document Collection

request: Zep.GetDocumentListRequest

requestOptions: Document.RequestOptions

client.document.batchUpdateDocuments(collectionName, { ...params }) -> Zep.SuccessResponse

📝 Description

Updates Documents in a specified DocumentCollection.

🔌 Usage

await client.document.batchUpdateDocuments("collectionName", [
    {
        uuid: "uuid",
    },
]);

⚙️ Parameters

collectionName: string — Name of the Document Collection

request: Zep.UpdateDocumentListRequest[]

requestOptions: Document.RequestOptions

client.document.getsADocumentFromADocumentCollectionByUuid(collectionName, documentUuid) -> Zep.ApidataDocument

📝 Description

Returns specified Document from a DocumentCollection.

🔌 Usage

await client.document.getsADocumentFromADocumentCollectionByUuid("collectionName", "documentUUID");

⚙️ Parameters

collectionName: string — Name of the Document Collection

documentUuid: string — UUID of the Document to be updated

requestOptions: Document.RequestOptions

client.document.deleteDocument(collectionName, documentUuid) -> Zep.SuccessResponse

📝 Description

Delete specified Document from a DocumentCollection.

🔌 Usage

await client.document.deleteDocument("collectionName", "documentUUID");

⚙️ Parameters

collectionName: string — Name of the Document Collection

documentUuid: string — UUID of the Document to be deleted

requestOptions: Document.RequestOptions

client.document.updatesADocument(collectionName, documentUuid, { ...params }) -> Zep.SuccessResponse

📝 Description

Updates a Document in a DocumentCollection by UUID

🔌 Usage

await client.document.updatesADocument("collectionName", "documentUUID");

⚙️ Parameters

collectionName: string — Name of the Document Collection

documentUuid: string — UUID of the Document to be updated

request: Zep.UpdateDocumentRequest

requestOptions: Document.RequestOptions

client.document.search(collectionName, { ...params }) -> Zep.ApidataDocumentSearchResponse

📝 Description

Searches over documents in a collection based on provided search criteria. One of text or metadata must be provided. Returns an empty list if no documents are found.

🔌 Usage

await client.document.search("collectionName");

⚙️ Parameters

collectionName: string — Name of the Document Collection

request: Zep.DocumentSearchPayload

requestOptions: Document.RequestOptions

Graph

client.graph.listEntityTypes() -> Zep.EntityTypeResponse

📝 Description

Returns all entity types for a project.

🔌 Usage

await client.graph.listEntityTypes();

⚙️ Parameters

requestOptions: Graph.RequestOptions

client.graph.setEntityTypesInternal({ ...params }) -> Zep.SuccessResponse

📝 Description

Sets the entity types for a project, replacing any existing ones.

🔌 Usage

await client.graph.setEntityTypesInternal();

⚙️ Parameters

request: Zep.EntityTypeRequest

requestOptions: Graph.RequestOptions

client.graph.add({ ...params }) -> Zep.Episode

📝 Description

Add data to the graph. Note: each subscription tier has different limits on the amount of data that can be added to the graph please refer to the pricing page for more information.

🔌 Usage

await client.graph.add({
    data: "data",
    type: "text",
});

⚙️ Parameters

request: Zep.AddDataRequest

requestOptions: Graph.RequestOptions

client.graph.addBatch({ ...params }) -> Zep.Episode[]

📝 Description

Add data to the graph in batch mode (each episode processed concurrently). Note: each subscription tier has different limits on the amount of data that can be added to the graph please refer to the pricing page for more information.

🔌 Usage

await client.graph.addBatch({
    episodes: [
        {
            data: "data",
            type: "text",
        },
    ],
});

⚙️ Parameters

request: Zep.AddDataBatchRequest

requestOptions: Graph.RequestOptions

client.graph.addFactTriple({ ...params }) -> Zep.AddTripleResponse

📝 Description

Add a fact triple for a user or group

🔌 Usage

await client.graph.addFactTriple({
    fact: "fact",
    factName: "fact_name",
    targetNodeName: "target_node_name",
});

⚙️ Parameters

request: Zep.AddTripleRequest

requestOptions: Graph.RequestOptions

client.graph.search({ ...params }) -> Zep.GraphSearchResults

📝 Description

Perform a graph search query.

🔌 Usage

await client.graph.search({
    query: "query",
});

⚙️ Parameters

request: Zep.GraphSearchQuery

requestOptions: Graph.RequestOptions

Memory

client.memory.getFact(factUuid) -> Zep.FactResponse

📝 Description

Deprecated API: get fact by uuid

🔌 Usage

await client.memory.getFact("factUUID");

⚙️ Parameters

factUuid: string — Fact UUID

requestOptions: Memory.RequestOptions

client.memory.deleteFact(factUuid) -> Zep.SuccessResponse

📝 Description

Deprecated API: delete a fact

🔌 Usage

await client.memory.deleteFact("factUUID");

⚙️ Parameters

factUuid: string — Fact UUID

requestOptions: Memory.RequestOptions

client.memory.addSession({ ...params }) -> Zep.Session

📝 Description

Creates a new session.

🔌 Usage

await client.memory.addSession({
    sessionId: "session_id",
    userId: "user_id",
});

⚙️ Parameters

request: Zep.CreateSessionRequest

requestOptions: Memory.RequestOptions

client.memory.listSessions({ ...params }) -> Zep.SessionListResponse

📝 Description

Returns all sessions.

🔌 Usage

await client.memory.listSessions();

⚙️ Parameters

request: Zep.MemoryListSessionsRequest

requestOptions: Memory.RequestOptions

client.memory.endSessions({ ...params }) -> Zep.EndSessionsResponse

📝 Description

Deprecated API: End multiple sessions by their IDs.

🔌 Usage

await client.memory.endSessions({
    sessionIds: ["session_ids"],
});

⚙️ Parameters

request: Zep.EndSessionsRequest

requestOptions: Memory.RequestOptions

client.memory.searchSessions({ ...params }) -> Zep.SessionSearchResponse

📝 Description

Deprecated API: Search sessions for the specified query.

🔌 Usage

await client.memory.searchSessions({
    text: "text",
});

⚙️ Parameters

request: Zep.SessionSearchQuery

requestOptions: Memory.RequestOptions

client.memory.getSession(sessionId) -> Zep.Session

📝 Description

Returns a session.

🔌 Usage

await client.memory.getSession("sessionId");

⚙️ Parameters

sessionId: string — The unique identifier of the session.

requestOptions: Memory.RequestOptions

client.memory.updateSession(sessionId, { ...params }) -> Zep.Session

📝 Description

Update Session Metadata

🔌 Usage

await client.memory.updateSession("sessionId", {
    metadata: {
        key: "value",
    },
});

⚙️ Parameters

sessionId: string — The unique identifier of the session.

request: Zep.UpdateSessionRequest

requestOptions: Memory.RequestOptions

client.memory.classifySession(sessionId, { ...params }) -> Zep.SessionClassification

📝 Description

Classifies a session.

🔌 Usage

await client.memory.classifySession("sessionId", {
    classes: ["classes"],
    name: "name",
});

⚙️ Parameters

sessionId: string — Session ID

request: Zep.ClassifySessionRequest

requestOptions: Memory.RequestOptions

client.memory.endSession(sessionId, { ...params }) -> Zep.EndSessionResponse

📝 Description

Deprecated API: End a session by ID.

🔌 Usage

await client.memory.endSession("sessionId");

⚙️ Parameters

sessionId: string — Session ID

request: Zep.EndSessionRequest

requestOptions: Memory.RequestOptions

client.memory.extractData(sessionId, { ...params }) -> Record

📝 Description

extract data from a session by session id

🔌 Usage

await client.memory.extractData("sessionId", {
    lastN: 1,
    modelSchema: "model_schema",
});

⚙️ Parameters

sessionId: string — Session ID

request: Zep.ExtractDataRequest

requestOptions: Memory.RequestOptions

client.memory.getSessionFacts(sessionId, { ...params }) -> Zep.FactsResponse

📝 Description

Deprecated API: get facts for a session

🔌 Usage

await client.memory.getSessionFacts("sessionId");

⚙️ Parameters

sessionId: string — Session ID

request: Zep.MemoryGetSessionFactsRequest

requestOptions: Memory.RequestOptions

client.memory.addSessionFacts(sessionId, { ...params }) -> Zep.SuccessResponse

📝 Description

Deprecated API: Adds facts to a session

🔌 Usage

await client.memory.addSessionFacts("sessionId");

⚙️ Parameters

sessionId: string — Session ID

request: Zep.AddFactsRequest

requestOptions: Memory.RequestOptions

client.memory.get(sessionId, { ...params }) -> Zep.Memory

📝 Description

Returns a memory for a given session.

🔌 Usage

await client.memory.get("sessionId");

⚙️ Parameters

sessionId: string — The ID of the session for which to retrieve memory.

request: Zep.MemoryGetRequest

requestOptions: Memory.RequestOptions

client.memory.add(sessionId, { ...params }) -> Zep.AddMemoryResponse

📝 Description

Add memory to the specified session.

🔌 Usage

await client.memory.add("sessionId", {
    messages: [
        {
            content: "content",
            roleType: "norole",
        },
    ],
});

⚙️ Parameters

sessionId: string — The ID of the session to which memory should be added.

request: Zep.AddMemoryRequest

requestOptions: Memory.RequestOptions

client.memory.delete(sessionId) -> Zep.SuccessResponse

📝 Description

Deletes a session.

🔌 Usage

await client.memory.delete("sessionId");

⚙️ Parameters

sessionId: string — The ID of the session for which memory should be deleted.

requestOptions: Memory.RequestOptions

client.memory.getSessionMessages(sessionId, { ...params }) -> Zep.MessageListResponse

📝 Description

Returns messages for a session.

🔌 Usage

await client.memory.getSessionMessages("sessionId");

⚙️ Parameters

sessionId: string — Session ID

request: Zep.MemoryGetSessionMessagesRequest

requestOptions: Memory.RequestOptions

client.memory.getSessionMessage(sessionId, messageUuid) -> Zep.Message

📝 Description

Returns a specific message from a session.

🔌 Usage

await client.memory.getSessionMessage("sessionId", "messageUUID");

⚙️ Parameters

sessionId: string — Soon to be deprecated as this is not needed.

messageUuid: string — The UUID of the message.

requestOptions: Memory.RequestOptions

client.memory.updateMessageMetadata(sessionId, messageUuid, { ...params }) -> Zep.Message

📝 Description

Updates the metadata of a message.

🔌 Usage

await client.memory.updateMessageMetadata("sessionId", "messageUUID", {
    metadata: {
        key: "value",
    },
});

⚙️ Parameters

sessionId: string — The ID of the session.

messageUuid: string — The UUID of the message.

request: Zep.ModelsMessageMetadataUpdate

requestOptions: Memory.RequestOptions

client.memory.search(sessionId, { ...params }) -> Zep.MemorySearchResult[]

🔌 Usage

await client.memory.search("sessionId");

⚙️ Parameters

sessionId: string — The ID of the session for which memory should be searched.

request: Zep.MemorySearchPayload

requestOptions: Memory.RequestOptions

client.memory.getSummaries(sessionId) -> Zep.SummaryListResponse

📝 Description

Deprecated API: Get session summaries by ID

🔌 Usage

await client.memory.getSummaries("sessionId");

⚙️ Parameters

sessionId: string — Session ID

requestOptions: Memory.RequestOptions

client.memory.synthesizeQuestion(sessionId, { ...params }) -> Zep.Question

📝 Description

Deprecated API: Synthesize a question from the last N messages in the chat history.

🔌 Usage

await client.memory.synthesizeQuestion("sessionId");

⚙️ Parameters

sessionId: string — The ID of the session.

request: Zep.MemorySynthesizeQuestionRequest

requestOptions: Memory.RequestOptions

Group

client.group.add({ ...params }) -> Zep.Group

📝 Description

Creates a new group.

🔌 Usage

await client.group.add({
    groupId: "group_id",
});

⚙️ Parameters

request: Zep.CreateGroupRequest

requestOptions: Group.RequestOptions

client.group.getAllGroups({ ...params }) -> Zep.GroupListResponse

📝 Description

Returns all groups.

🔌 Usage

await client.group.getAllGroups();

⚙️ Parameters

request: Zep.GetGroupsOrderedRequest

requestOptions: Group.RequestOptions

client.group.getGroup(groupId) -> Zep.Group

📝 Description

Returns a group.

🔌 Usage

await client.group.getGroup("groupId");

⚙️ Parameters

groupId: string — The group_id of the group to get.

requestOptions: Group.RequestOptions

client.group.delete(groupId) -> Zep.SuccessResponse

📝 Description

Deletes a group.

🔌 Usage

await client.group.delete("groupId");

⚙️ Parameters

groupId: string — Group ID

requestOptions: Group.RequestOptions

client.group.update(groupId, { ...params }) -> Zep.Group

📝 Description

Updates information about a group.

🔌 Usage

await client.group.update("groupId");

⚙️ Parameters

groupId: string — Group ID

request: Zep.UpdateGroupRequest

requestOptions: Group.RequestOptions

client.group.getFacts(groupId) -> Zep.FactsResponse

📝 Description

Deprecated: Use Get Group Edges instead.

🔌 Usage

await client.group.getFacts("groupId");

⚙️ Parameters

groupId: string — The group_id of the group to get.

requestOptions: Group.RequestOptions

User

client.user.add({ ...params }) -> Zep.User

📝 Description

Adds a user.

🔌 Usage

await client.user.add();

⚙️ Parameters

request: Zep.CreateUserRequest

requestOptions: User.RequestOptions

client.user.listOrdered({ ...params }) -> Zep.UserListResponse

📝 Description

Returns all users.

🔌 Usage

await client.user.listOrdered();

⚙️ Parameters

request: Zep.UserListOrderedRequest

requestOptions: User.RequestOptions

client.user.get(userId) -> Zep.User

📝 Description

Returns a user.

🔌 Usage

await client.user.get("userId");

⚙️ Parameters

userId: string — The user_id of the user to get.

requestOptions: User.RequestOptions

client.user.delete(userId) -> Zep.SuccessResponse

📝 Description

Deletes a user.

🔌 Usage

await client.user.delete("userId");

⚙️ Parameters

userId: string — User ID

requestOptions: User.RequestOptions

client.user.update(userId, { ...params }) -> Zep.User

📝 Description

Updates a user.

🔌 Usage

await client.user.update("userId");

⚙️ Parameters

userId: string — User ID

request: Zep.UpdateUserRequest

requestOptions: User.RequestOptions

client.user.getFacts(userId) -> Zep.FactsResponse

📝 Description

Deprecated: Use Get User Edges instead.

🔌 Usage

await client.user.getFacts("userId");

⚙️ Parameters

userId: string — The user_id of the user to get.

requestOptions: User.RequestOptions

client.user.getNode(userId) -> Zep.UserNodeResponse

📝 Description

Returns a user's node.

🔌 Usage

await client.user.getNode("userId");

⚙️ Parameters

userId: string — The user_id of the user to get the node for.

requestOptions: User.RequestOptions

client.user.getSessions(userId) -> Zep.Session[]

📝 Description

Returns all sessions for a user.

🔌 Usage

await client.user.getSessions("userId");

⚙️ Parameters

userId: string — User ID

requestOptions: User.RequestOptions

Graph Edge

client.graph.edge.getByGroupId(groupId, { ...params }) -> Zep.EntityEdge[]

📝 Description

Returns all edges for a group.

🔌 Usage

await client.graph.edge.getByGroupId("group_id", {});

⚙️ Parameters

groupId: string — Group ID

request: Zep.GraphEdgesRequest

requestOptions: Edge.RequestOptions

client.graph.edge.getByUserId(userId, { ...params }) -> Zep.EntityEdge[]

📝 Description

Returns all edges for a user.

🔌 Usage

await client.graph.edge.getByUserId("user_id", {});

⚙️ Parameters

userId: string — User ID

request: Zep.GraphEdgesRequest

requestOptions: Edge.RequestOptions

client.graph.edge.get(uuid) -> Zep.EntityEdge

📝 Description

Returns a specific edge by its UUID.

🔌 Usage

await client.graph.edge.get("uuid");

⚙️ Parameters

uuid: string — Edge UUID

requestOptions: Edge.RequestOptions

client.graph.edge.delete(uuid) -> Zep.SuccessResponse

📝 Description

Deletes an edge by UUID.

🔌 Usage

await client.graph.edge.delete("uuid");

⚙️ Parameters

uuid: string — Edge UUID

requestOptions: Edge.RequestOptions

Graph Episode

client.graph.episode.getByGroupId(groupId, { ...params }) -> Zep.EpisodeResponse

📝 Description

Returns episodes by group id.

🔌 Usage

await client.graph.episode.getByGroupId("group_id");

⚙️ Parameters

groupId: string — Group ID

request: Zep.graph.EpisodeGetByGroupIdRequest

requestOptions: Episode.RequestOptions

client.graph.episode.getByUserId(userId, { ...params }) -> Zep.EpisodeResponse

📝 Description

Returns episodes by user id.

🔌 Usage

await client.graph.episode.getByUserId("user_id");

⚙️ Parameters

userId: string — User ID

request: Zep.graph.EpisodeGetByUserIdRequest

requestOptions: Episode.RequestOptions

client.graph.episode.get(uuid) -> Zep.Episode

📝 Description

Returns episodes by UUID

🔌 Usage

await client.graph.episode.get("uuid");

⚙️ Parameters

uuid: string — Episode UUID

requestOptions: Episode.RequestOptions

client.graph.episode.delete(uuid) -> Zep.SuccessResponse

📝 Description

Deletes an episode by its UUID.

🔌 Usage

await client.graph.episode.delete("uuid");

⚙️ Parameters

uuid: string — Episode UUID

requestOptions: Episode.RequestOptions

client.graph.episode.getNodesAndEdges(uuid) -> Zep.GraphSearchResults

📝 Description

Returns nodes and edges mentioned in an episode

🔌 Usage

await client.graph.episode.getNodesAndEdges("uuid");

⚙️ Parameters

uuid: string — Episode uuid

requestOptions: Episode.RequestOptions

Graph Node

client.graph.node.getByGroupId(groupId, { ...params }) -> Zep.EntityNode[]

📝 Description

Returns all nodes for a group.

🔌 Usage

await client.graph.node.getByGroupId("group_id", {});

⚙️ Parameters

groupId: string — Group ID

request: Zep.GraphNodesRequest

requestOptions: Node.RequestOptions

client.graph.node.getByUserId(userId, { ...params }) -> Zep.EntityNode[]

📝 Description

Returns all nodes for a user

🔌 Usage

await client.graph.node.getByUserId("user_id", {});

⚙️ Parameters

userId: string — User ID

request: Zep.GraphNodesRequest

requestOptions: Node.RequestOptions

client.graph.node.get(uuid) -> Zep.EntityNode

📝 Description

Returns a specific node by its UUID.

🔌 Usage

await client.graph.node.get("uuid");

⚙️ Parameters

uuid: string — Node UUID

requestOptions: Node.RequestOptions