Build AI Agents that EVOLVE Over Time

Key Concepts

• AI Agents & Long-Term Memory: The importance of long-term memory for AI agents to achieve human-like behavior and personalization.
• Mem Zero: An open-source Python library for building self-learning AI agents with long-term memory.
• RAG (Retrieval-Augmented Generation): Using documents to teach AI agents, but insufficient for true memory.
• User ID Segregation: Storing and retrieving memories based on individual user IDs to prevent data contamination.
• Vector Database: Storing memory embeddings for efficient retrieval.
• Superbase Integration: Using Superbase for user authentication and vector storage.
• Streamlit UI: A simple user interface for demonstrating Superbase authentication and memory segregation.
• Memory Addition & Search: Core functionalities of Mem Zero for storing and retrieving memories.
• Conflict Resolution: Mem Zero's ability to prevent memory duplication.
• Advanced RAG Techniques: Reranking relevant scores and including metadata for robust long-term memory.

Long-Term Memory for AI Agents: The Problem and Solution

The video addresses the issue of AI agents lacking long-term memory, hindering their ability to act intelligently and personalize interactions. While Retrieval-Augmented Generation (RAG) is useful for teaching agents from documents, it doesn't provide the ability to remember past conversations and user-specific information. The solution presented is Mem Zero, an open-source Python library designed to equip AI agents with long-term memory capabilities.

Demonstrating the Need for Long-Term Memory

The video contrasts the performance of an LLM (Gemini 2.0 Flash) without long-term memory against an agent built with Mem Zero.

• LLM without Memory: When given a description of a tech stack (Reddis, Superbase) in one conversation, the LLM fails to recall this information in a subsequent, new conversation. It provides generic database considerations and mentions irrelevant technologies.
• Agent with Mem Zero: The Mem Zero-powered agent, when given the same tech stack description, successfully recalls the specific technologies (Superbase, Postgress, Reddis, Fast API) in a new conversation and provides tailored advice. This demonstrates the ability to build a user-specific knowledge base.

Getting Started with Mem Zero

The video outlines the ease of getting started with Mem Zero:

1. Installation: pip install Memzero AI
2. Hosting: Option to use Mem Zero's platform or self-host for free.
3. GitHub Repo: The video provides a link to a GitHub repository containing code examples and setup instructions.

Building a Basic Implementation (Version 1)

The video walks through building a basic Mem Zero implementation:

1. Import Libraries and Environment Variables: Includes OpenAI API key.
2. Configuration: Sets up the configuration for the LLM (GPT4 Mini) and creates OpenAI and Mem Zero clients.
3. chat_with_memories Function:
   • Takes the user's message and user ID as input.
   • Retrieves relevant memories using mem_zero_client.search(), limiting to three memories.
   • Creates a system prompt that includes the retrieved memories.
   • Passes the system prompt and user message to the OpenAI client.
   • Appends the user message and AI response to the messages.
   • Calls mem_zero_client.add() to extract and store memories.
   • Returns the response.
4. Main Function: Loops to take user input, calls chat_with_memories, and prints the response. Uses a default user ID.

The video demonstrates that even without conversation history, the agent can recall preferences (e.g., cheese preferences) from long-term memory.

Integrating Superbase for Vector Storage (Version 2)

The video demonstrates how to integrate Superbase for storing memories:

1. Configuration Change: Modifies the Mem Zero client configuration to use Superbase for vector storage.
2. Connection String: Sets up the Superbase connection string using environment variables.
3. Superbase Setup: Shows how to retrieve the connection string from the Superbase instance.
4. Dynamic Model: Makes the model dynamic based on an environment variable.

The video shows how memories are stored in the memories table within the VEX schema in Superbase, including the vectorized text, user ID, and metadata. It also demonstrates that the agent can recall memories even after the script is restarted, proving the persistence of long-term memory.

Superbase Authentication and User ID Management (Version 3)

The video demonstrates how to set up Superbase authentication and use the user ID from the signed-in user for memory segregation:

1. Streamlit UI: Creates a simple Streamlit user interface for sign-up and sign-in.
2. Superbase Authentication: Uses Superbase URL and key for authentication.
3. User ID Retrieval: Stores the user in the session state and retrieves the user ID from the Superbase user object.
4. Dynamic User ID: Passes the dynamic user ID to the chat_with_memories function.

The video demonstrates that memories are stored separately for different users based on their Superbase user IDs. It shows how logging in with different accounts results in different memories being retrieved, ensuring data segregation.

Mem Zero Behind the Scenes

The video explains the core functionalities of Mem Zero:

• Adding Memories: Messages are processed by an LLM to extract key memories, which are then added to a vector database. Mem Zero also handles conflict resolution to prevent memory duplication.
• Searching Memories: An LLM intelligently rewrites the query to extract relevant information from the vector database. The retrieved memories are then fed into the AI agent.

Mem Zero implements advanced RAG techniques, such as reranking relevant scores and including metadata, to ensure robust long-term memory.

Conclusion

Mem Zero provides a powerful and customizable solution for implementing long-term memory in AI agents. Its ease of integration, user ID segregation, and advanced RAG techniques make it a valuable tool for building personalized and intelligent AI applications. The video encourages viewers to explore Mem Zero's capabilities and integrate it into their own AI agent projects.