ceven

Mem0

Stores and retrieves long term user preferences and interaction history to give your AI agents a persistent memory across different sessions and platforms.

Try Mem0 in Ceven

Ask Ceven anything
Standard

Why use Ceven?

  1. AI native Mem0 integration

    • Describe the outcome and Ceven picks the right Mem0 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 Mem0 data, across all 47 of its actions.

  2. Managed auth

    • Built in OAuth with automatic token refresh and rotation.
    • One place to manage, scope, and revoke Mem0 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 Mem0, when, and on whose behalf.
    • The agent pauses and asks when Mem0 is unclear instead of plowing ahead.

  4. Enterprise grade security

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

Supported tools

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

Add memory records
Use this to store new facts or preferences inferred from a conversation. Associate records with a user id or agent id.
Semantic search
Query memories using natural language to find the most relevant context based on meaning rather than keywords.
Retrieve entity memories
Pull all stored memories for a specific user, agent, or application to build a full profile.
Update memory text
Modify the content of a specific memory record when a user preference changes or a fact is corrected.
Delete memory by id
Permanently remove a specific piece of information from the memory layer using its unique identifier.
Get memory history
Retrieve the version history of a memory to see how a specific piece of information has evolved over time.
Create user
Initialize a new user entity in Mem0 to begin tracking their specific memories and interactions.
Create agent
Set up a new agent identity to track memories specific to a particular bot persona or workflow.
List memories
Retrieve a paginated list of memories using filters like date ranges or metadata tags.
Delete memories by filter
Clear out groups of memories based on user id or agent id. Use with caution to avoid data loss.
Get user stats
Pull a summary of memory activity including total records created and search volume for a user.
Export memories
Start an asynchronous job to export stored memories according to a specific schema for backup or analysis.
Add member to project
Adds an existing user to a project (identified by `project id` within organization `org id`), assigning a valid system role.
Add new memory records
Stores new memory records from a list of messages, optionally inferring structured content; requires association via `agent id`, `user id`, `app id`, or `run id`.
Add organization member
Adds a new member, who must be a registered user, to an organization, assigning them a specific role.
Create a new agent
Creates a new agent with a unique `agent id` and an optional `name`; additional metadata may be assigned by the system.
Create a new agent run
Creates a new agent run in the mem0.ai system.
Create a new application
Creates a new application, allowing metadata to be passed in the request body (not an explicit field in this action's request model); ensure `app id` is unique to avoid potential errors or unintended updates.
Create a new organization entry
Creates a new organization entry using the provided name and returns its details.
Create a new user
Creates a new user with the specified unique `user id` and supports associating `metadata` (not part of the request schema fields).
Create an export job with schema
Initiates an asynchronous job to export memories, structured by a schema provided in the request body and allowing optional filters.
Create memory entry
Lists/searches existing memory entries with filtering and pagination; critically, this action retrieves memories and does *not* create new ones, despite its name.
Create project
Creates a new project with a given name within an organization that must already exist.
Delete an organization
Permanently deletes an existing organization identified by its unique id.
Delete entity by type and id
Call to permanently and irreversibly hard delete an existing entity (user, agent, app, or run) and all its associated data, using its type and id.
Delete memories
Deletes memories matching specified filter criteria; omitting all filters may result in deleting all memories. required: at least one of agent id, user id, app id, or run id must be provided.
Delete memory batch with uuids
Deletes a batch of up to 1000 existing memories, identified by their uuids, in a single api call.
Delete project
Permanently deletes a specific project and all its associated data from an organization; this action cannot be undone and requires the project to exist within the specified organization.
Delete project member
Removes an existing member, specified by username, from a project, immediately revoking their project specific access; the user is not removed from the organization.
Export data based on filters
Retrieves memory export data, optionally filtered by various identifiers (e.g., user id); without filters, it may return all accessible or recent exports based on default behavior.

30 actions · scroll to see them all

Frequently asked questions

Mem0 uses a self improving mechanism to manage contradictions. When new information is added that contradicts an existing memory, the system can either create a new version or update the existing record based on the confidence of the new data. Through the Ceven interface, you can use the retrieve memory history action to see exactly how a piece of information changed. This allows you to audit the evolution of a user profile. If the AI incorrectly updated a preference, you can manually revert to a previous version by using the update memory text action with the historical data, ensuring the source of truth remains accurate.
Semantic search uses vector embeddings to find memories that are conceptually related to a query, even if the exact words do not match. For example, searching for coffee might return memories about espresso. Filtered retrieval is a strict query based on metadata like user id, date ranges, or specific tags. In Ceven, you typically use semantic search when you need to find a specific fact you cannot name exactly, and you use filtered retrieval when you need every single record associated with a specific customer account to generate a comprehensive summary report for a human manager.
Yes. Mem0 supports a hierarchical structure where memories are tied to users, agents, and applications, all of which reside within projects and organizations. This is critical for multi tenant applications. Within Ceven, you can manage these boundaries using the create project and add organization member actions. This ensures that an AI agent working for one client cannot accidentally retrieve memories belonging to another client. The permission model is strictly enforced at the API level, so the agent only sees data within the scope of the provided organization and project identifiers during the workflow execution.
Mem0 does not impose a hard cap on the number of memories per user, but performance and cost are tied to your specific plan tier. One quirk of the Mem0 API is that very large memory sets for a single entity can increase the latency of semantic search results due to the way the vector index is traversed. If you notice slow response times for power users with thousands of memories, we recommend using the delete memories action to prune stale or irrelevant data. Regularly cleaning up old context keeps the retrieval speed high and the AI responses crisp and relevant.
Ceven acts as a secure conduit. We do not store the memories ourselves; they reside entirely within your Mem0 account. When a workflow triggers a memory write, Ceven sends the encrypted payload directly to the Mem0 API. You can control exactly what gets stored by adding a filtering step in your Ceven workflow to strip out personally identifiable information before it reaches the memory layer. Because you own the Mem0 API key and organization, you maintain full control over data deletion and export, ensuring compliance with privacy laws like GDPR or CCPA by simply deleting the user entity.
Yes, that is one of its primary strengths. By associating memories with a user id rather than a specific agent id, multiple agents can share the same memory pool. For instance, a sales agent can record a lead preference in Mem0, and later, an onboarding agent can retrieve that same preference to personalize the welcome call. In Ceven, you achieve this by consistently using the same user id across different workflow triggers. This creates a unified user profile that follows the customer regardless of which AI persona they are interacting with at any given moment.
Memories are typically available for retrieval in near real time. Once the add memory records action returns a success response, the data is indexed and available for semantic search. However, there can be a slight propagation delay of a few seconds in some cloud regions. If your workflow requires immediate read after write, we recommend a short delay or using the retrieve memory by id action, which fetches the record directly from the database rather than relying on the vector index, ensuring you get the most current state of the information.
Deleting a user entity is a permanent and irreversible action. When you use the delete entity by type and id action for a user, Mem0 removes the user profile and every single memory associated with that specific id. This is a hard delete, meaning the data cannot be recovered via the API. We strongly suggest using the export data based on filters action to create a backup of a user's memory history before performing a deletion. Once the entity is gone, any Ceven workflows attempting to retrieve memories for that id will return an empty result.

Alternatives to Mem0

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

Pinecone logoPineconeZep logoZepWeaviate logoWeaviate

Try Ceven on your stack

Plug Ceven on top of the tools you already run. Connect Mem0 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