ceven

Zep

Syncs long term memory and knowledge graphs across your AI agents to ensure consistent user context and factual recall. Use this to maintain a persistent memory layer that evolves with every user interaction.

Try Zep in Ceven

Ask Ceven anything
Standard

Why use Ceven?

  1. AI native Zep integration

    • Describe the outcome and Ceven picks the right Zep calls, fills the parameters, and checks the result.
    • Structured, agent friendly tool schemas so each call runs reliably instead of by guesswork.
    • Rich coverage for reading, writing, and querying your Zep data, across all 41 of its actions.

  2. Managed auth

    • Built in OAuth with automatic token refresh and rotation.
    • One place to manage, scope, and revoke Zep access.
    • Per user and per environment credentials instead of shared keys.

  3. Agent optimized design

    • Actions are tuned from real success and error rates so reliability climbs over time.
    • Full execution logs so you always know what ran in Zep, when, and on whose behalf.
    • The agent pauses and asks when Zep is unclear instead of plowing ahead.

  4. Enterprise grade security

    • Fine grained access so you control which agents and people can reach Zep.
    • Least privilege by default, read scopes first and only the writes a workflow needs.
    • A full audit trail of every Zep action to support review and sign off.

Supported tools

Every action Ceven's agents can run on Zep, and when to use it.

Add fact triple
Use this when you need to add an explicit relationship between two entities as a subject predicate object triple.
Add session memory
Store specific conversation history or context messages into a designated Zep session.
Add thread messages
Push chat messages to a thread to ingest them into the user knowledge graph for long term recall.
Create user
Establish a new user profile with email and metadata to begin tracking their unique memory graph.
Create thread
Start a new conversation thread for an existing user to isolate specific interaction contexts.
Create group
Create a shared namespace for multi user graph management to enable shared context across a team.
Graph search
Perform a hybrid search using semantic similarity and BM25 to find entities or episodes in the graph.
Get thread user context
Pull the most relevant memory from past threads based on the current conversation state.
Get user node
Retrieve the generated user summary and associated facts from the user graph node.
Get session memory
Pull historical data and relevant facts associated with a specific session ID.
Get task status
Check the progress of asynchronous operations like batch additions or graph cloning.
Delete user
Permanently remove a user and all associated threads to handle right to be forgotten requests.
Clone Graph
Tool to clone a user or group graph with new identifiers in Zep. Use when you need to create test copies of user data, migrate user graphs to new identifiers, or set up template graphs for new users. This is an asynchronous operation that r
Create Graph
Tool to create a new graph by adding data to Zep. Use when you need to add text, message, or JSON data to a user's graph or a specific graph. The data is processed and an episode node is created in the graph.
Create Session
Tool to create a new session in Zep for storing conversation memory. Use when you need to establish a new conversation context linked to an existing user. The user must be created first before creating a session.
Delete Graph
Tool to delete a graph from Zep. Use when you need to permanently remove a graph and all associated data.
Delete Group
Tool to delete a group from Zep. Use when you need to permanently remove a group and its associated data.
Delete Session Memory
Tool to delete a session and its memory from Zep. Use when you need to permanently remove all memory data associated with a specific session.
Delete Thread
Tool to delete a thread and its messages from Zep. Note that deleting a thread removes the thread and its messages from the thread history but does not delete associated data in the user's knowledge graph.
Get Edge by UUID
Tool to retrieve a specific edge by its UUID from the Zep knowledge graph. Use when you need to fetch detailed information about a relationship between nodes, including the semantic fact, connected nodes, and temporal metadata.
Get Graph by ID
Tool to retrieve a graph by its unique identifier from Zep. Use when you need to fetch details about a specific graph including its name, description, and timestamps.
Get Group by ID
Tool to retrieve a group by ID from Zep. Use when you need to fetch detailed information about a specific group including its configuration and metadata.
Get Node Entity Edges
Tool to retrieve all entity edges for a specific node in the Zep knowledge graph. Use when you need to fetch relationship information, facts, and connections for a given node UUID.
Get Project Info
Tool to retrieve project information based on the provided API key. Use when you need to fetch project details including UUID, name, description, and creation timestamp.
Get Session by ID
Tool to retrieve a session by its unique identifier from Zep. Use when you need to fetch details about a specific session including user association, timestamps, classifications, and metadata.
Get Session Message by UUID
Tool to retrieve a specific message by UUID from a Zep session. Use when you need to fetch a single message's details by its unique identifier from a particular session.
Get Session Messages
Tool to retrieve messages for a given session from Zep. Use when you need to fetch the message history for a specific session with optional pagination support.
Get Thread Messages
Tool to retrieve conversation history for a specific thread from Zep. Use when you need to fetch the chat message history with optional pagination support via limit, cursor, or lastn parameters.
Get User by ID
Tool to retrieve a user by their user ID from Zep. Use when you need to fetch detailed information about a specific user including their profile, metadata, and configuration settings.
Get User Nodes
Tool to retrieve all nodes for a specific user from their graph in Zep. Use when you need to fetch entity information, preferences, and knowledge graph data for a user. Supports pagination via limit and uuid_cursor parameters.

30 actions · scroll to see them all

Frequently asked questions

Zep provides granular control over user data through specific management tools. When a user requests their data be deleted, the Delete User action removes the user and all associated threads and artifacts from the system. This is designed specifically to help companies comply with GDPR and other right to be forgotten regulations. Because the memory is partitioned by user ID, there is no leakage between different user graphs unless you explicitly use the group management features to create shared namespaces. All data is encrypted and access is managed via API keys that can be rotated or revoked through the Zep dashboard to ensure that only authorized agents can access sensitive user context.
A session in Zep is primarily used for short term conversation memory and immediate context. It stores the recent exchange of messages to maintain flow. A thread is a more permanent structure that allows for the ingestion of messages into the long term user knowledge graph. While a session might be ephemeral or focused on a single task, a thread serves as the bridge that allows Zep to extract lasting facts about a user. For example, a session handles the current chat, but the thread ensures that a mentioned preference for a specific product is saved to the user node for use in future sessions months later.
Yes, Zep supports this through the Group feature. By creating a group, you establish a shared namespace where multiple users can contribute to and draw from a common knowledge graph. This is ideal for B2B scenarios where an entire company account needs to share a set of project requirements or brand guidelines across different employee agents. You can manage these groups using the Create Group and Update Group actions, allowing you to define shared fact rating instructions that govern how information is prioritized and recalled for everyone within that specific group, ensuring a single source of truth for the organization.
Zep employs a dual approach by combining semantic similarity with BM25 full text search. Semantic search uses vector embeddings to find concepts that are meaning based, even if the exact words differ. BM25 handles the keyword matching, which is critical for finding specific names, technical IDs, or unique terms that embeddings might smooth over. When you trigger a Graph Search, Zep runs both queries and merges the results to provide a highly accurate set of entities and episodes. This prevents the common AI problem where a vector search misses a specific product code but a keyword search would have found it instantly.
Zep has specific architectural limits regarding how it processes data. One critical quirk is that many graph operations, such as adding fact triples or cloning graphs, are asynchronous. This means the API returns a task ID rather than the finished result. You must use the Get Task Status tool to poll for completion. If you attempt to push massive batches of data without monitoring these tasks, you may encounter rate limits or find that your agent is querying the graph before the data has actually been indexed. High volume accounts should implement a polling loop to ensure data consistency before executing subsequent read operations.
The user summary is an automated distillation of all interactions stored within that users threads. Zep analyzes the ingested messages and extracts key attributes, preferences, and recurring themes to create a concise summary node. This node acts as a high level snapshot of the user. You can retrieve this via the Get User Node action. The summary is updated dynamically as new information is added to the graph, meaning the AI does not have to re read every single past message to understand who the user is; it simply reads the most recent summary node to get immediate context.
Yes, you can override or supplement automated learning using the Add Fact Triple tool. While Zep is excellent at extracting facts automatically, there are times when an AI might misinterpret a user statement. By manually pushing a subject predicate object triple, you can explicitly define a relationship in the knowledge graph. This manual entry takes precedence in the context window, ensuring that the agent relies on the corrected fact. This is particularly useful for onboarding new clients where specific business rules must be adhered to strictly and cannot be left to the probabilistic nature of automated extraction.
Zep is designed to be a standalone memory layer rather than a plug in for another vector database. It manages its own indexing, embedding, and graph storage to optimize for the specific needs of AI memory. While you can pull data out of Zep via the API to send to other systems, it is intended to be the primary source of truth for user context. This integrated approach allows Zep to handle the complex task of turning raw chat logs into a structured graph, a process that would require significant custom engineering if you were trying to build it on top of a generic vector store.

Alternatives to Zep

Other tools that solve a similar problem. Ceven supports these too, so you can switch or run more than one at once.

Pinecone logoPineconeMemGPT logoMemGPTWeaviate logoWeaviate

Try Ceven on your stack

Plug Ceven on top of the tools you already run. Connect Zep and the rest of your stack, describe the outcome, and its agents handle the work end to end, days of it in minutes.

Get started for free