Skip to main content

​
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

1

Automatic Learning

As you chat, AI identifies important information:
  • Your preferences and style
  • Facts about your projects
  • Technical requirements
  • Personal context
  • Recurring patterns
2

Intelligent Storage

Information is stored in a semantic memory database:
  • Organized by relevance
  • Tagged with context
  • Connected to related memories
  • Timestamped for recency
3

Smart Retrieval

When you chat, relevant memories are automatically retrieved:
  • Based on current context
  • Weighted by importance
  • Filtered by recency
  • Matched semantically
4

Contextual Application

AI uses memories to provide better responses:
  • Personalized suggestions
  • Consistent style
  • Remembered preferences
  • Contextual understanding

​
Types of 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.

​
Enabling Memory

Enable for all conversations:
  1. Go to Settings > Memory
  2. Toggle Enable Memory System
  3. Choose memory scope:
    • Personal only
    • Include projects
    • Full context
Memory is enabled by default for all users.

​
What Gets Remembered

​
Automatically Captured

  • 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 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...
  • 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]
  • 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

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.
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.
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.
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

Remember that I prefer detailed explanations

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

Keep in mind: Deadline is March 15th

​
Viewing Your Memories

1

Access Memory Dashboard

Go to Settings > Memory > View All Memories
2

Browse Memories

See all stored information organized by:
  • Category (Bio, Chat, Project, Preference)
  • Date added
  • Source conversation
  • Relevance score
3

Search Memories

Use search to find specific memories:
Search: "API endpoints"
4

Manage Individual Memories

For each memory:
  • Edit the content
  • Change category
  • Adjust importance
  • Delete if no longer needed

​
Managing Memory

​
Memory Settings

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

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

​
Memory Isolation

  • Only visible to you
  • Never shared with team
  • Not visible in shared conversations
  • Persist across all your chats
  • Scoped to specific project
  • Can be shared with team (your choice)
  • Only used in project conversations
  • Managed by project admins
  • 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

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
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.
Solutions:
  • Adjust memory quality to “Strict”
  • Review and delete unnecessary memories
  • Use project-scoped memory instead of global
  • Clear memories for completed projects
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:
  1. Be explicit - Clearly state what’s important
  2. Keep updated - Correct outdated information
  3. Organize by project - Use project memory for team work
  4. Review regularly - Clean up unnecessary memories
  5. Respect privacy - Don’t store sensitive personal data
  6. Use commands - “Remember”, “Update”, “Forget” are powerful
  7. Provide context - Explain why things matter
  8. 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!