Building Long-Term Memory for AI Agents with Memzero

# Install Memzero
pip install memzero

# Install additional dependencies
pip install openai weaviate-client python-dotenv

import os
from dotenv import load_dotenv
from memzero import MemClient

# Load environment variables
load_dotenv()

# Initialize the client with your Memzero API key
mem_client = MemClient(
    api_key=os.getenv("MEMZERO_API_KEY")
)

# Create a sequence of messages
messages = [
    {"role": "user", "content": "Hi there! My name is Dave."},
    {"role": "assistant", "content": "Nice to meet you, Dave!"},
    {"role": "user", "content": "I like to build automations."}
]

# Add these messages to memory
mem_client.add(
    messages=messages,
    user_id="user123"  # Optional: Associate memories with a specific user
)

# Search for relevant memories
response = mem_client.search(
    query="What shall we build today?",
    user_id="user123",
    limit=1
)

print(response)
# Output will include: "Dave likes to build automations" with a relevance score

# Search for a different memory
response = mem_client.search(
    query="What is my name?",
    user_id="user123",
    limit=1
)

print(response)
# Output will include: "Username is Dave" with a relevance score

import os
from dotenv import load_dotenv
from memzero import Memory

# Load environment variables
load_dotenv()

# Initialize the Memory object with default settings
# This uses in-memory storage by default
memory = Memory()

# Create a sequence of messages
messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "What kind of movies do you enjoy?"},
    {"role": "user", "content": "I love sci-fi movies but I'm not a big fan of thriller movies."},
    {"role": "assistant", "content": "Great! I'd recommend watching Dune or Interstellar then."}
]

# Add these messages to memory
results = memory.add(messages=messages)

# Get all stored memories
all_memories = memory.get_all()
print(all_memories)
# Output will include: "Planning to watch a movie tonight", "Loves sci-fi movies", "Not a big fan of thriller movies"

# Search for relevant memories
memories = memory.search(
    query="What kind of movies should I recommend?",
    limit=3
)

print(memories)
# Output will include memories related to movie preferences

import os
from dotenv import load_dotenv
from memzero import Memory
from memzero.config import MemoryConfig, VectorStoreConfig, LLMConfig

# Load environment variables
load_dotenv()

# Configure Memzero to use Weaviate
config = MemoryConfig(
    vector_store=VectorStoreConfig(
        provider="weaviate",
        url="http://localhost:8080",
        index_name="MemZero"
    ),
    llm=LLMConfig(
        provider="openai",
        model="gpt-4o-mini",
        api_key=os.getenv("OPENAI_API_KEY")
    )
)

# Initialize Memory with the configuration
memory = Memory(config=config)

import os
from dotenv import load_dotenv
from memzero import Memory
from memzero.config import MemoryConfig, VectorStoreConfig, LLMConfig
from openai import OpenAI

# Load environment variables
load_dotenv()

# Configure OpenAI client
openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Configure Memzero
config = MemoryConfig(
    vector_store=VectorStoreConfig(
        provider="weaviate",
        url="http://localhost:8080",
        index_name="MemZero"
    ),
    llm=LLMConfig(
        provider="openai",
        model="gpt-4o-mini",
        api_key=os.getenv("OPENAI_API_KEY")
    )
)

# Initialize Memory
memory = Memory(config=config)

def chat_with_memory():
    """Simple chat interface with memory capabilities"""
    conversation = []
    system_prompt = {"role": "system", "content": "You are a helpful AI assistant. Use the provided memories to personalize your responses."}
    conversation.append(system_prompt)

    print("Chat with AI (type 'exit' to quit):")

    while True:
        # Get user input
        user_input = input("You: ")
        if user_input.lower() == 'exit':
            break

        # Add user message to conversation
        conversation.append({"role": "user", "content": user_input})

        # Retrieve relevant memories
        relevant_memories = memory.search(query=user_input, limit=3)

        # Print retrieved memories (for demonstration)
        if relevant_memories:
            print("Retrieved memories:")
            for mem in relevant_memories:
                print(f"- {mem.text} (Score: {mem.score:.2f})")

        # Create a context with memories for the AI
        memory_context = ""
        if relevant_memories:
            memory_context = "I know the following about you:\n"
            for mem in relevant_memories:
                memory_context += f"- {mem.text}\n"

        # Prepare messages for OpenAI
        ai_messages = conversation.copy()
        if memory_context:
            # Insert memory context as a system message
            ai_messages.insert(1, {"role": "system", "content": memory_context})

        # Get AI response
        response = openai_client.chat.completions.create(
            model="gpt-4o-mini",
            messages=ai_messages
        )

        # Extract response text
        assistant_message = response.choices[0].message.content

        # Print assistant response
        print(f"Assistant: {assistant_message}")

        # Add assistant message to conversation
        conversation.append({"role": "assistant", "content": assistant_message})

        # Update memory with the new conversation
        memory.add(messages=conversation[-2:])  # Add just the latest user and assistant messages

if __name__ == "__main__":
    chat_with_memory()

# Custom prompt for extracting facts
custom_fact_prompt = """
Given the conversation history below, extract key facts about the user.
Focus specifically on:
1. Personal preferences (likes/dislikes)
2. Demographic information
3. Goals and objectives
4. Technical background
5. Current problems they're trying to solve

Conversation history:
{messages}

Format your response as a list of clear, concise facts, one per line.
"""

# Custom prompt for updating memories
custom_update_prompt = """
You are tasked with managing a database of memories about a user.

Current memories:
{memories}

New potential memories:
{facts}

For each new potential memory, decide whether to:
1. ADD - if it's completely new information
2. UPDATE - if it contradicts or enhances existing information
3. DELETE - if it invalidates existing information
4. NONE - if it's redundant or not useful

Format your response as a JSON array of operations, where each operation has:
- operation: "add", "update", "delete", or "none"
- memory: the memory text
- reason: brief explanation of your decision

Only include operations that are necessary. Prioritize accuracy over quantity.
"""

# Configure Memzero with custom prompts
config = MemoryConfig(
    vector_store=VectorStoreConfig(
        provider="weaviate",
        url="http://localhost:8080",
        index_name="MemZero"
    ),
    llm=LLMConfig(
        provider="openai",
        model="gpt-4o-mini",
        api_key=os.getenv("OPENAI_API_KEY")
    ),
    fact_extraction_prompt=custom_fact_prompt,
    update_memory_prompt=custom_update_prompt
)

# Initialize Memory with custom configuration
memory = Memory(config=config)