> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zerotwo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Managing Memory Data

> View, edit, delete, and export your Memory data to maintain control over what ZeroTwo remembers

ZeroTwo gives you full control over your Memory data. You can view everything the system has learned about you, edit or remove specific memories, reset categories, or export all your data.

## Accessing Memory settings

<Steps>
  <Step title="Open settings">
    Navigate to your ZeroTwo settings panel using the settings icon in the interface or the keyboard shortcut.
  </Step>

  <Step title="Find Memory section">
    Locate the Memory or Data Management section within settings.
  </Step>

  <Step title="View Memory overview">
    See a summary of stored memories organized by category (biographical, projects, preferences, etc.).
  </Step>
</Steps>

<Info>
  Memory settings are also accessible through your profile menu under Privacy & Data settings.
</Info>

## Viewing your memories

### Memory dashboard

The Memory dashboard provides an organized view of all stored information:

<Tabs>
  <Tab title="Biographical">
    Personal and professional information about you:

    ```text theme={null}
    Professional Role:
    - Senior full-stack developer
    - 8 years of experience
    - Focus on web applications

    Technical Skills:
    - JavaScript, TypeScript, Python
    - React, Node.js, PostgreSQL
    - Docker, AWS, CI/CD

    Work Context:
    - Building SaaS products
    - Team of 5 developers
    - Fintech industry
    ```
  </Tab>

  <Tab title="Projects">
    Active and past projects:

    ```text theme={null}
    Current Projects:
    1. TaskFlow Pro
       - Description: Project management SaaS
       - Tech: Next.js, TypeScript, Supabase
       - Stage: MVP development
       - Started: January 2024

    2. Analytics Dashboard
       - Description: Real-time data visualization
       - Tech: React, D3.js, Python backend
       - Stage: Beta testing
    ```
  </Tab>

  <Tab title="Preferences">
    Your technical and communication preferences:

    ```text theme={null}
    Code Style:
    - Language: TypeScript preferred
    - Pattern: Functional programming
    - Comments: Detailed for complex logic
    - Testing: Jest for unit tests

    Response Style:
    - Concise explanations
    - Include code examples
    - Highlight security concerns
    - Prefer practical over theoretical
    ```
  </Tab>

  <Tab title="Conversation">
    Context from previous interactions:

    ```text theme={null}
    Recent Topics:
    - Authentication implementation
    - Database schema design
    - Performance optimization
    - WebSocket real-time features

    Common Patterns:
    - Frequently asks about TypeScript types
    - Regular code reviews
    - Focus on production-ready code
    ```
  </Tab>
</Tabs>

### Searching memories

<Tip>
  Use the search functionality to find specific memories:

  ```text theme={null}
  Search examples:
  - "authentication" - Find all auth-related memories
  - "Next.js" - Find framework-specific context
  - "preferences" - Find your stored preferences
  - "project" - List all project memories
  ```
</Tip>

## Editing memories

You have several options for modifying stored information:

### Edit individual memories

<Steps>
  <Step title="Select a memory">
    Click on any memory entry to view its details.
  </Step>

  <Step title="Click edit">
    Use the edit button to modify the memory content.
  </Step>

  <Step title="Update information">
    Change the text to reflect current, accurate information.

    ```text theme={null}
    Before: "Using Redux for state management"
    After: "Using Zustand for state management"
    ```
  </Step>

  <Step title="Save changes">
    Confirm your edits. Updated information will be used in future conversations.
  </Step>
</Steps>

### Batch updates

For multiple related memories:

```text theme={null}
Example: Updating tech stack
1. Select all memories containing "React"
2. Choose "Batch Update"
3. Replace "React" with "Vue"
4. Apply to all selected memories
```

<Warning>
  Batch updates affect multiple memories simultaneously. Review selections carefully before applying changes.
</Warning>

### Correcting in conversation

You can also update Memory directly through conversation:

<CodeGroup>
  ```text Direct update theme={null}
  "Update my memory: I now prefer Bun over Node.js for new projects"
  ```

  ```text Correction theme={null}
  "Actually, I switched from PostgreSQL to MongoDB for this project"
  ```

  ```text Addition theme={null}
  "Remember that I'm working remotely from the EU timezone"
  ```
</CodeGroup>

The AI will acknowledge the update and adjust Memory accordingly.

## Deleting memories

### Delete specific memories

<Steps>
  <Step title="Find the memory">
    Locate the memory you want to remove using search or browsing.
  </Step>

  <Step title="Select delete">
    Click the delete icon or button next to the memory entry.
  </Step>

  <Step title="Confirm deletion">
    Confirm you want to permanently remove this memory.

    <Check>
      The memory is immediately removed and will not appear in future conversations.
    </Check>
  </Step>
</Steps>

### Delete by category

Remove entire categories of memories:

<AccordionGroup>
  <Accordion title="Delete project memories">
    Remove all context about a specific project (useful when a project ends):

    ```text theme={null}
    1. Go to Projects section
    2. Select project "TaskFlow Pro"
    3. Click "Delete Project Memories"
    4. Confirm deletion

    Result: All TaskFlow Pro context removed, other projects unaffected
    ```
  </Accordion>

  <Accordion title="Delete conversation memories">
    Clear memory of past interactions while keeping biographical info:

    ```text theme={null}
    1. Go to Conversation Memories
    2. Click "Clear Conversation History"
    3. Choose time range (last week, last month, all)
    4. Confirm deletion
    ```
  </Accordion>

  <Accordion title="Delete preferences">
    Reset your stored preferences:

    ```text theme={null}
    1. Go to Preferences section
    2. Select specific preferences or "All Preferences"
    3. Click "Delete Selected"
    4. Confirm—Memory will learn fresh preferences
    ```
  </Accordion>
</AccordionGroup>

### Conversational deletion

You can also delete memories through conversation:

```text theme={null}
"Forget about my authentication implementation preferences"
"Remove the context about the old project I mentioned"
"Delete memories related to Python—I don't use it anymore"
```

## Resetting Memory

### Partial reset

Reset specific aspects while keeping others:

<Tabs>
  <Tab title="Reset project context">
    Clear all project-related memories but keep personal preferences:

    ```text theme={null}
    Use case: Starting fresh on new projects
    Keeps: Your role, skills, preferences, style
    Removes: All project contexts and technical decisions
    ```
  </Tab>

  <Tab title="Reset preferences">
    Clear your stored preferences to let Memory learn anew:

    ```text theme={null}
    Use case: Your preferences have changed significantly
    Keeps: Biographical info, project context
    Removes: All technical and communication preferences
    ```
  </Tab>

  <Tab title="Reset conversation history">
    Clear memory of past interactions:

    ```text theme={null}
    Use case: Too much outdated context accumulated
    Keeps: Biographical info, projects, preferences
    Removes: Context from previous conversations
    ```
  </Tab>
</Tabs>

### Complete reset

Completely clear all Memory data:

<Steps>
  <Step title="Access reset options">
    Navigate to Memory settings and find the "Reset All Memory" option.
  </Step>

  <Step title="Review implications">
    <Warning>
      **This action:**

      * Removes all stored biographical information
      * Deletes all project contexts
      * Clears all preferences and style information
      * Resets conversation memory
      * **Cannot be undone**

      Consider exporting your data first if you might want to reference it later.
    </Warning>
  </Step>

  <Step title="Confirm reset">
    Type confirmation phrase (usually "RESET MY MEMORY") and confirm.
  </Step>

  <Step title="Start fresh">
    <Check>
      Memory is now empty. ZeroTwo will learn about you naturally as you have new conversations.
    </Check>
  </Step>
</Steps>

## Exporting Memory data

Export your Memory data for backup, review, or portability:

### Export formats

<Tabs>
  <Tab title="JSON">
    Structured, machine-readable format:

    ```json theme={null}
    {
      "biographical": {
        "role": "Senior full-stack developer",
        "experience_years": 8,
        "skills": ["JavaScript", "TypeScript", "React", "Node.js"],
        "work_context": "Building SaaS products in fintech"
      },
      "projects": [
        {
          "name": "TaskFlow Pro",
          "description": "Project management SaaS",
          "tech_stack": ["Next.js", "TypeScript", "Supabase"],
          "stage": "MVP development"
        }
      ],
      "preferences": {
        "code_style": {
          "language": "TypeScript",
          "pattern": "Functional programming"
        }
      },
      "export_date": "2024-03-15T10:30:00Z"
    }
    ```
  </Tab>

  <Tab title="Markdown">
    Human-readable format for documentation:

    ```markdown theme={null}
    # ZeroTwo Memory Export
    Export Date: March 15, 2024

    ## Biographical Information
    - **Role**: Senior full-stack developer
    - **Experience**: 8 years
    - **Skills**: JavaScript, TypeScript, React, Node.js

    ## Projects
    ### TaskFlow Pro
    - **Description**: Project management SaaS
    - **Tech Stack**: Next.js, TypeScript, Supabase
    - **Stage**: MVP development

    ## Preferences
    ### Code Style
    - Language: TypeScript preferred
    - Pattern: Functional programming
    ```
  </Tab>

  <Tab title="CSV">
    Spreadsheet-compatible format:

    ```csv theme={null}
    Category,Type,Key,Value,Date_Added
    Biographical,Role,Position,Senior full-stack developer,2024-01-15
    Biographical,Skill,Language,TypeScript,2024-01-15
    Projects,Active,Name,TaskFlow Pro,2024-02-01
    Preferences,Code,Language,TypeScript,2024-01-20
    ```
  </Tab>
</Tabs>

### Export process

<Steps>
  <Step title="Choose export format">
    Select JSON, Markdown, or CSV based on your needs.
  </Step>

  <Step title="Select categories">
    Choose which memory categories to include:

    * All memories (complete export)
    * Specific categories (biographical, projects, etc.)
    * Date range (last month, last year, all time)
  </Step>

  <Step title="Generate export">
    Click "Export Memory Data" to generate the file.
  </Step>

  <Step title="Download">
    <Check>
      Download the generated file to your device. The file is generated on-demand and not stored on servers.
    </Check>
  </Step>
</Steps>

<Tip>
  **Export use cases:**

  * **Backup**: Regular exports for data backup
  * **Review**: Audit what Memory has learned
  * **Migration**: Transfer context when switching accounts
  * **Analysis**: Understand patterns in your work
  * **Compliance**: Maintain records for data governance
</Tip>

## Importing Memory data

If you've previously exported Memory data, you can import it:

<Steps>
  <Step title="Access import">
    Navigate to Memory settings and find the "Import Memory" option.
  </Step>

  <Step title="Upload file">
    Select your exported JSON or CSV file to upload.
  </Step>

  <Step title="Review and map">
    Review the data to be imported. Map fields if importing from CSV.
  </Step>

  <Step title="Choose merge strategy">
    Decide how to handle conflicts:

    * **Merge**: Combine with existing memories (default)
    * **Replace**: Overwrite existing memories with imported data
    * **Add only new**: Import only memories that don't exist
  </Step>

  <Step title="Confirm import">
    <Check>
      Complete the import. Imported memories are immediately available in conversations.
    </Check>
  </Step>
</Steps>

<Warning>
  **Import considerations:**

  * Validate JSON format before importing
  * Review data for accuracy—imported memories are treated as fact
  * Consider starting with a small import to test
  * Backup current memory before large imports
</Warning>

## Privacy and data retention

### Data storage

<Info>
  **How Memory data is stored:**

  * Encrypted at rest in secure databases
  * Associated only with your account
  * Not shared across users or organizations
  * Not used for model training
  * Retained according to your privacy settings
</Info>

### Data deletion permanence

When you delete Memory data:

* ✅ Immediately removed from active Memory
* ✅ No longer appears in conversations
* ✅ Removed from backups within 30 days
* ✅ Fully compliant with data protection regulations

See [Data and Compliance](/privacy/data-and-compliance) for complete privacy information.

## Troubleshooting Memory

<AccordionGroup>
  <Accordion title="Memory seems outdated">
    **Solution:**

    1. Explicitly correct in conversation: "Update: I now use..."
    2. Or edit directly in Memory settings
    3. Give it 1-2 conversations to fully update context
  </Accordion>

  <Accordion title="Too much irrelevant memory">
    **Solution:**

    1. Review and delete specific irrelevant memories
    2. Reset conversation memory to clear accumulated context
    3. Be more explicit about what's important vs. temporary
  </Accordion>

  <Accordion title="Memory not recalling information">
    **Solution:**

    1. Check if Memory is enabled in settings
    2. Verify the information was explicitly stated (not just implied)
    3. Try mentioning the context explicitly to reinforce it
    4. Check that the conversation is connected to your account
  </Accordion>

  <Accordion title="Conflicting memories">
    **Solution:**

    1. Explicitly state the current, correct information
    2. Review and delete outdated conflicting entries
    3. Use specific project names to disambiguate contexts
  </Accordion>
</AccordionGroup>

## Best practices

<Steps>
  <Step title="Regular reviews">
    Periodically review your Memory (monthly or quarterly) to ensure accuracy and relevance.
  </Step>

  <Step title="Proactive updates">
    When major changes occur (new project, tech stack change, role change), explicitly update Memory.
  </Step>

  <Step title="Category organization">
    Keep memories well-organized by category for easier management.
  </Step>

  <Step title="Export backups">
    Export your Memory data occasionally for backup and review purposes.
  </Step>

  <Step title="Privacy hygiene">
    Regularly review for any sensitive information and remove it promptly.
  </Step>
</Steps>

## Memory in team contexts

For [team workspaces](/projects/create-project):

<CardGroup cols={2}>
  <Card title="Personal Memory" icon="user">
    **Your control:**

    * Fully managed by you
    * View, edit, delete anytime
    * Export your data
    * Reset your preferences

    **Privacy:**

    * Not visible to team members
    * Not shared with team admins
  </Card>

  <Card title="Team Memory" icon="users">
    **Shared control:**

    * Visible to team members
    * Editable by members (based on permissions)
    * Managed collectively

    **Best practices:**

    * Focus on project context
    * Document technical decisions
    * Keep sensitive info in personal memory
  </Card>
</CardGroup>

## Next steps

<CardGroup cols={2}>
  <Card title="How Memory works" icon="brain" href="/memory/how-memory-works">
    Understand the Memory system in depth
  </Card>

  <Card title="Custom instructions" icon="sliders" href="/prompts/custom-instructions-patterns">
    Complement Memory with persistent instructions
  </Card>

  <Card title="Privacy and data" icon="shield" href="/privacy/data-and-compliance">
    Learn about data privacy and compliance
  </Card>

  <Card title="Data export" icon="download" href="/account/data-export-and-deletion">
    Complete data export and deletion options
  </Card>
</CardGroup>