How to build an OpenAI Agent with persistent memory

# Install required packages
pip install memorisdk openai-agents python-dotenv

import os
import asyncio
from dotenv import load_dotenv
from textwrap import dedent

# Import Memori for memory capabilities
from memori import Memori, create_memory_tool

# Import OpenAI Agents SDK
from agents import Agent, Runner, function_tool

# Load environment variables
load_dotenv()

print("All packages imported successfully!")
print("Memori + OpenAI Agents integration ready!")

print("Initializing Memori memory system...")

# Initialize Memori with both conscious and auto memory modes
memory_system = Memori(
    database_connect="sqlite:///cookbook_memory.db",  # Local SQLite database
    conscious_ingest=True,  # Short-term working memory
    auto_ingest=True,       # Dynamic memory search
    verbose=False,          # Less debug output
    namespace="cookbook_demo",  # Organize memories by project
)

# Enable the memory system
memory_system.enable()

print("Memory system initialized!")
print("Memory database: cookbook_memory.db")
print("Namespace: cookbook_demo")

# Create the built-in memory search tool
memory_tool = create_memory_tool(memory_system)

@function_tool
def search_memory(query: str) -> str:
    """
    Search the agent's memory for past conversations, user preferences, and information.
    Use this to find relevant context from previous interactions.

    Args:
        query: What to search for in memory (e.g., "user's name", "favorite color", "Python projects")

    Returns:
        str: Search results from the agent's memory
    """
    try:
        if not query.strip():
            return "Please provide a search query"

        print(f"Searching memory for: {query}")

        # Use Memori's memory tool to search
        result = memory_tool.execute(query=query.strip())
        return result if result else "No relevant memories found"

    except Exception as e:
        return f"Memory search error: {str(e)}"

@function_tool
def remember_user_info(info: str) -> str:
    """
    Remember important information about the user for future conversations.
    Use this when the user shares preferences, goals, or other important details.

    Args:
        info: The information to remember (e.g., "User's name is Alice", "Prefers Python over JavaScript")

    Returns:
        str: Confirmation of what was remembered
    """
    try:
        print(f"Storing user info: {info}")

        # Store in Memori's memory system
        memory_system.record_conversation(
            user_input=f"User shared: {info}",
            ai_output=f"I'll remember that: {info}"
        )

        return f"Remembered: {info}"

    except Exception as e:
        return f"Error storing information: {str(e)}"

print("Memory tools created successfully!")
print("Available tools:")
print("   - search_memory: Find past conversations and preferences")
print("   - remember_user_info: Store new information about the user")

# Create the memory-enhanced OpenAI Agent
memory_agent = Agent(
    name="Memory-Enhanced Assistant",
    instructions=dedent(
        """
        You are a helpful AI assistant with persistent memory capabilities. You can remember
        past conversations and user preferences across different chat sessions.

        Your memory abilities:
        1. search_memory: Search for relevant past conversations, user preferences,
           and any information from previous interactions
        2. remember_user_info: Store important information about the user

        Guidelines for using memory:
        - ALWAYS start by searching your memory for relevant context before responding
        - When users share important information (name, preferences, goals, projects),
          use remember_user_info to store it
        - Be conversational and personalize responses based on remembered information
        - Reference past conversations naturally when relevant
        - If this seems like a first conversation, introduce your memory capabilities

        Be helpful, friendly, and make good use of your memory to provide personalized assistance!
        """
    ),
    model="gpt-4o-mini",
    tools=[search_memory, remember_user_info],
)

print("Memory-Enhanced Assistant created!")
print("This agent can:")
print("   - Remember past conversations")
print("   - Learn your preferences")
print("   - Search through memory")
print("   - Provide personalized responses")

async def chat_with_memory_agent(user_input: str) -> str:
    """
    Process user input through the memory-enhanced agent and store the conversation.

    Args:
        user_input: What the user said

    Returns:
        str: The agent's response
    """
    try:
        print(f"Processing: {user_input[:50]}{'...' if len(user_input) > 50 else ''}")

        # Run the agent with the user input
        result = await Runner.run(memory_agent, input=user_input)

        # Get the response content
        response_content = result.final_output if hasattr(result, "final_output") else str(result)

        # Store the conversation in Memori's memory system
        memory_system.record_conversation(
            user_input=user_input,
            ai_output=response_content
        )

        return response_content

    except Exception as e:
        error_msg = f"Sorry, I encountered an error: {str(e)}"
        print(f"Error: {error_msg}")
        return error_msg

print("Chat function ready!")

print("Demo 1: First Conversation - Building Memory")
print("=" * 50)

# First conversation - introducing ourselves
user_message = "Hi! I'm Alice and I'm a Python developer. I love working with data science and I'm currently learning about AI agents."

print(f"User: {user_message}")
print("\\\\nAssistant (thinking...)\\\\n")

response = await chat_with_memory_agent(user_message)
print(f"Assistant: {response}")

print("\\\\nDemo 2: Second Conversation - Memory in Action")
print("=" * 50)

# Second conversation - asking for help
user_message = "Can you help me with a project? I want to build something cool but I'm not sure what."

print(f"User: {user_message}")
print("\\\\nAssistant (thinking...)\\\\n")

response = await chat_with_memory_agent(user_message)
print(f"Assistant: {response}")

print("\\\\nDemo 3: Adding More Preferences")
print("=" * 50)

# Adding more preferences
user_message = "I also love using Jupyter notebooks for my data analysis work, and I prefer using pandas and matplotlib for visualization. I'm working on a machine learning project about predicting house prices."

print(f"User: {user_message}")
print("\\\\nAssistant (thinking...)\\\\n")

response = await chat_with_memory_agent(user_message)
print(f"Assistant: {response}")

print("\\\\nDemo 4: Testing Memory Recall")
print("=" * 50)

# Testing memory recall
user_message = "What do you remember about my current projects and interests?"

print(f"User: {user_message}")
print("\\\\nAssistant (thinking...)\\\\n")

response = await chat_with_memory_agent(user_message)
print(f"Assistant: {response}")

print("\\\\nDemo 5: Memory-Based Recommendations")
print("=" * 50)

# Getting personalized recommendations
user_message = "I have some free time this weekend. What would you recommend I work on or learn about?"

print(f"User: {user_message}")
print("\\\\nAssistant (thinking...)\\\\n")

response = await chat_with_memory_agent(user_message)
print(f"Assistant: {response}")

async def interactive_chat():
    """
    Interactive chat session with the memory-enhanced agent.
    """
    print("\\\\nInteractive Chat Session Started!")
    print("=" * 50)
    print("Start chatting with your memory-enhanced assistant!")
    print("Try asking about previous conversations or sharing new information.")
    print("Type 'quit', 'exit', or 'stop' to end the session.\\\\n")

    conversation_count = 0

    while True:
        try:
            # Get user input
            user_input = input("You: ").strip()

            # Check for exit commands
            if user_input.lower() in ["quit", "exit", "stop", "bye"]:
                print("\\\\nAssistant: Goodbye! I'll remember our conversation for next time.")
                break

            if not user_input:
                continue

            conversation_count += 1
            print(f"\\\\nAssistant (thinking... #{conversation_count})")

            # Get response from memory-enhanced agent
            response = await chat_with_memory_agent(user_input)

            print(f"Assistant: {response}\\\\n")

        except KeyboardInterrupt:
            print("\\\\n\\\\nAssistant: Goodbye! I'll remember our conversation for next time.")
            break
        except Exception as e:
            print(f"\\\\nError: {str(e)}")
            print("Please try again.\\\\n")

    print("\\\\nSession Summary:")
    print(f"   - Conversations: {conversation_count}")
    print(f"   - Memory database: cookbook_memory.db")
    print(f"   - Namespace: cookbook_demo")
    print("\\\\nAll conversations are saved and will be available in future sessions!")

# Start the interactive chat (uncomment the line below to run)
# await interactive_chat()

print("Interactive chat function ready!")
print("Uncomment the line above and run the cell to start chatting!")

print("Memory System Statistics")
print("=" * 50)

try:
    # Get memory statistics
    stats = memory_system.get_memory_stats()
    print(f"Memory Statistics:")
    for key, value in stats.items():
        print(f"   - {key}: {value}")
except Exception as e:
    print(f"Memory stats not available: {str(e)}")

print("\\\\nSearching for stored preferences...")
try:
    # Search for user preferences
    preferences = memory_tool.execute(query="user preferences python data science")
    print(f"Found preferences:\\\\n{preferences}")
except Exception as e:
    print(f"Error searching memory: {str(e)}")

print("\\\\nMemory Database Information:")
print("   - Database file: cookbook_memory.db")
print("   - Namespace: cookbook_demo")
print("   - Conscious mode: Enabled (short-term memory)")
print("   - Auto mode: Enabled (dynamic search)")