Memory System - ZeroTwo Docs

What is Memory?

ZeroTwo’s memory system allows AI to remember important information across conversations, building a personalized understanding of you, your preferences, and your work. This creates a more intelligent, context-aware experience over time.

Memory is powered by mem0, a sophisticated system that stores and retrieves relevant information automatically as you chat.

How Memory Works

Automatic Learning

As you chat, AI identifies important information:

Your preferences and style
Facts about your projects
Technical requirements
Personal context
Recurring patterns

Intelligent Storage

Information is stored in a semantic memory database:

Organized by relevance
Tagged with context
Connected to related memories
Timestamped for recency

Smart Retrieval

When you chat, relevant memories are automatically retrieved:

Based on current context
Weighted by importance
Filtered by recency
Matched semantically

Contextual Application

AI uses memories to provide better responses:

Personalized suggestions
Consistent style
Remembered preferences
Contextual understanding

Types of Memory

Bio Memory
Chat Memory
Project Memory
Preference Memory

Personal profile informationWhat it remembers:

Your name and role
Professional background
Skills and expertise
Work context
Communication preferences

Example:

"I'm a senior frontend developer specializing in React"

AI remembers this and tailors code examples to your level.

Conversation-specific contextWhat it remembers:

Current project details
Technical decisions
Ongoing tasks
Important facts
References mentioned

Example:

"We're using Next.js 14 with the App Router"

AI remembers project stack without repeated explanations.

Workspace-specific knowledgeWhat it remembers:

Project goals
Team members
Tech stack
Standards and conventions
Key documents

Example:

"Our team uses TypeScript strict mode and Tailwind CSS"

Consistent across all project conversations.

How you like things doneWhat it remembers:

Code style preferences
Communication style
Output format preferences
Tool preferences
Language preferences

Example:

"Always include TypeScript types in code examples"

AI automatically applies your preferences.

Enabling Memory

Global Setting
Per Conversation
Project-Level

Enable for all conversations:

Go to Settings > Memory
Toggle Enable Memory System
Choose memory scope:
- Personal only
- Include projects
- Full context

Memory is enabled by default for all users.

What Gets Remembered

Automatically Captured

Personal Information

Your name, role, and background
Professional expertise and skills
Work context and responsibilities
Communication style preferences
Language and format preferences

Example interaction:

You: I'm a DevOps engineer working with Kubernetes

AI: [Remembers your role and expertise]

Later conversation...
AI: Given your Kubernetes experience, you could use 
Helm charts for this deployment...

Project Details

Project names and descriptions
Technology stack and tools
Team members and roles
Important decisions made
Key milestones and dates

Example:

You: We're building an e-commerce platform with Next.js

AI: [Remembers project context]

Next day...
AI: For your e-commerce platform, let's add the 
shopping cart feature...

Technical Preferences

Coding conventions
Naming patterns
Framework choices
Library preferences
Architecture decisions

Example:

You: Use functional components with hooks, not class components

AI: [Remembers code style]

Later...
AI: Here's a functional component with hooks:
[Generates code in preferred style]

Important Facts

Key dates and deadlines
Resource constraints
Requirements and specifications
Business rules
Domain knowledge

Example:

You: Our API rate limit is 100 requests per minute

AI: [Remembers constraint]

Later...
AI: I'll design this to respect your 100 req/min 
rate limit...

Explicitly Added

You can explicitly add memories:

Remember: I prefer TypeScript over JavaScript for all projects

Store this: Our staging environment is at staging.example.com

Keep in mind: Budget constraint is $5000 for this project

Use “Remember” or “Store this” to explicitly add important information to memory.

Using Memory Effectively

Best Practices

Be Explicit About Important Info

Tell AI what’s important:✅ Good:

Remember: We use camelCase for variable names and 
PascalCase for components

❌ Less effective:

We sometimes use camelCase

Clear, explicit statements are better remembered.

Update When Things Change

Keep memory current:

Update: We switched from MongoDB to PostgreSQL

Correction: The API endpoint is actually /api/v2/users

AI will update or replace old information.

Provide Context

Explain why things matter:✅ Better:

Remember: Always check for null values because our 
legacy API sometimes returns null instead of empty arrays

vs just “check for null”Context helps AI apply knowledge appropriately.

Use Project Context

Organize by project:Information in projects is scoped to that workspace:

Team members only
Project-specific
Organized context

Better than mixing everything in personal memory.

Memory Commands

Add Memory
Update Memory
Query Memory
Remove Memory

Remember that I prefer detailed explanations

Store this: Production database is db.prod.example.com

Keep in mind: Deadline is March 15th

Update: I now prefer concise responses

Correction: The deadline moved to March 20th

Change: We're using PostgreSQL 15 now, not 14

What do you remember about my project?

Show me what you know about my tech stack

What preferences have I set?

Forget about the old API endpoint

Remove: MongoDB information (we switched databases)

Delete what you know about Project Alpha

Viewing Your Memories

Access Memory Dashboard

Go to Settings > Memory > View All Memories

Browse Memories

See all stored information organized by:

Category (Bio, Chat, Project, Preference)
Date added
Source conversation
Relevance score

Search Memories

Use search to find specific memories:

Search: "API endpoints"

Manage Individual Memories

For each memory:

Edit the content
Change category
Adjust importance
Delete if no longer needed

Managing Memory

Memory Settings

Retention
Scope
Sharing
Quality

How long to keep memories:

Forever: Keep until manually deleted
1 year: Auto-delete after 12 months
6 months: Auto-delete after 6 months
3 months: Auto-delete after 3 months

Older memories can be manually preserved.

Bulk Operations

Export Memories

Download all memories as JSON or CSV

Import Memories

Upload memories from previous export

Clear Project

Delete all memories for specific project

Reset All

Clear all memories and start fresh

Bulk deletion operations cannot be undone. Export your memories first if you might need them later.

Privacy & Security

Data Protection

Encrypted Storage

All memories encrypted at rest

Secure Access

Only you can access your personal memories

No Training Data

Memories never used to train AI models

Full Control

View, edit, or delete any memory anytime

What’s Remembered vs. Not

✅ Remembered
❌ Not Remembered

Information you explicitly provide
Important facts from conversations
Your stated preferences
Project details you share
Technical specifications
Work-related context

Memory Isolation

Personal Memories

Only visible to you
Never shared with team
Not visible in shared conversations
Persist across all your chats

Project Memories

Scoped to specific project
Can be shared with team (your choice)
Only used in project conversations
Managed by project admins

Temporary Conversations

Memory can be disabled per chat
No permanent storage
Good for sensitive topics
Fresh context each time

Advanced Features

Memory Importance

Adjust how important different memories are:

[High importance] Remember: Never use deprecated APIs

[Low importance] I mentioned I like coffee (not work-related)

AI prioritizes high-importance memories when context is limited.

Memory Connections

Memories can be linked:

This relates to what I told you about the database schema

AI creates connections between related memories for better context.

Temporal Context

Memories include time context:

Recent memories weighted higher
Outdated information flagged
Historical context maintained
Evolution tracked over time

Memory Triggers

Set conditions for when memories apply:

Remember this only for frontend work: Use React hooks

When discussing the mobile app, remember we target iOS 14+

Context-aware application of memories.

Troubleshooting

AI not remembering something

Possible causes:

Memory disabled for that conversation
Information not clear or explicit enough
Conflicting information causing uncertainty
Memory filtered as low importance

Solutions:

Explicitly state: “Remember this: [fact]”
Rephrase more clearly
Check memory settings
Manually add to memory dashboard

Outdated information being used

Fix:

Update the memory: “Update: [new information]”
Delete old memory from dashboard
Explicitly correct: “That’s no longer accurate, now it’s…”

Old memories can linger if not updated.

Too much irrelevant context

Solutions:

Adjust memory quality to “Strict”
Review and delete unnecessary memories
Use project-scoped memory instead of global
Clear memories for completed projects

Privacy concerns

Actions:

Review all memories in dashboard
Delete sensitive information
Adjust sharing settings
Use temporary conversations for sensitive topics
Export and clear if switching accounts

Use Cases

Developers

Remember: 
- I use VS Code with Vim keybindings
- Prefer functional programming style
- Tech stack: React, TypeScript, Node.js, PostgreSQL
- Always include error handling in examples

AI generates code matching your style and stack automatically.

Writers

Remember:
- I write technical blog posts
- Audience: intermediate developers
- Tone: friendly but professional
- Always include code examples
- Prefer shorter paragraphs

Consistent writing style across all content.

Project Managers

Remember:
- Team: 8 developers, 2 designers, 1 PM
- Sprint length: 2 weeks
- Using Jira for tracking
- Standup at 9:30 AM daily
- Current sprint: Sprint 23

Context-aware project planning and organization.

Researchers

Remember:
- Field: Machine Learning
- Focus: Natural Language Processing
- Using PyTorch framework
- Prefer academic paper citations
- Working on transformer models

Relevant research suggestions and technical depth.

Best Practices Summary

Memory best practices:

Be explicit - Clearly state what’s important
Keep updated - Correct outdated information
Organize by project - Use project memory for team work
Review regularly - Clean up unnecessary memories
Respect privacy - Don’t store sensitive personal data
Use commands - “Remember”, “Update”, “Forget” are powerful
Provide context - Explain why things matter
Test and refine - Check if AI is using memories correctly

Next Steps

Custom Instructions

Set persistent instructions for all chats

Projects

Organize memories in project workspaces

Assistants

Create assistants with specific knowledge

Privacy Settings

Learn about data privacy and control

Memory makes ZeroTwo smarter over time - building a personalized AI assistant that truly knows you and your work!

​What is Memory?

​How Memory Works

​Types of Memory

​Enabling Memory

​What Gets Remembered

​Automatically Captured

​Explicitly Added

​Using Memory Effectively

​Best Practices

​Memory Commands

​Viewing Your Memories

​Managing Memory

​Memory Settings

​Bulk Operations

Export Memories

Import Memories

Clear Project

Reset All

​Privacy & Security

​Data Protection

Encrypted Storage

Secure Access

No Training Data

Full Control

​What’s Remembered vs. Not

​Memory Isolation

​Advanced Features

​Memory Importance

​Memory Connections

​Temporal Context

​Memory Triggers

​Troubleshooting

​Use Cases

​Developers

​Writers

​Project Managers

​Researchers

​Best Practices Summary

​Next Steps

Custom Instructions

Projects

Assistants

Privacy Settings

What is Memory?

How Memory Works

Types of Memory

Enabling Memory

What Gets Remembered

Automatically Captured

Explicitly Added

Using Memory Effectively

Best Practices

Memory Commands

Viewing Your Memories

Managing Memory

Memory Settings

Bulk Operations

Privacy & Security

Data Protection

What’s Remembered vs. Not

Memory Isolation

Advanced Features

Memory Importance

Memory Connections

Temporal Context

Memory Triggers

Troubleshooting

Use Cases

Developers

Writers

Project Managers

Researchers

Best Practices Summary

Next Steps