import

name	import
description	Imports memories from an exported Markdown file or MEMORY.md into the current project. Use when migrating from another project, restoring from backup, importing Claude Code native MEMORY.md content, or setting up a new project with existing knowledge.

Mem0 Import

Import memories from a mem0 export file into the current project.

Execution

Step 1: Determine the export file to import

If the user provided a filename as an argument to /mem0:import <filename>, use that file.

Otherwise, list .md files in the current directory whose names contain mem0-export:

ls -1 *.md 2>/dev/null | grep mem0-export || echo "No export files found"

If multiple files are found, ask the user which one to import. If none are found, print:

No mem0-export files found in the current directory.
Run /mem0:export first, or provide the filename: /mem0:import <path-to-file>

Step 2: Parse the export file

Determine the plugin root. Use the appropriate variable for the current platform:

• Claude Code: ${CLAUDE_PLUGIN_ROOT}
• Codex: ${CODEX_PLUGIN_ROOT}
• Cursor: ${CURSOR_PLUGIN_ROOT}

Run the parser script to extract memory records as JSON:

python3 "<PLUGIN_ROOT>/scripts/parse_export_file.py" "<path-to-export-file>"

This outputs a JSON array where each element has:

• id — original memory ID (for reference only; a new ID will be assigned on import)
• type — metadata type
• confidence — metadata confidence value
• branch — metadata branch
• files — list of associated files
• categories — list of categories
• content — the memory text

If the script fails or outputs [], print:

Failed to parse <filename> or file contains no valid memory blocks.

and stop.

Step 3: Resolve identity

Determine the active identity:

• user_id from MEM0_USER_ID env var, else $USER, else "default"
• project_id (used as app_id) from MEM0_PROJECT_ID env var, or via the project resolver

Step 4: Import each memory

For each record in the parsed JSON array, call add_memory with:

• text="<record.content>"
• user_id=<active_user_id>
• app_id=<active_project_id>
• metadata={
  • "type": "<record.type>" (if non-empty)
  • "confidence": "<record.confidence>" (if non-empty)
  • "branch": "<record.branch>" (if non-empty)
  • "files": <record.files> (the list, if non-empty)
  • "source": "import"
  • }
• infer=False

Notes:

• Do NOT pass the original id — the platform assigns a new ID.
• Skip records where content is empty (the parser already filters these, but be defensive).
• Continue importing even if individual records fail; track the count of successes.

Step 5: Print results

Imported <N> memories into project <project_id>

Where <N> is the number of successfully imported memories.

If any failed:

Imported <N>/<total> memories into project <project_id> (<failed> failed)

Importing from competing AI tools (--tools)

When invoked with --tools (e.g., /mem0:import --tools), detect and import from competing AI tool configuration files:

Supported tools

Tool	File/directory
Cursor	.cursorrules
GitHub Copilot	.github/copilot-instructions.md
Cline	memory-bank/ (directory of .md files)
Continue	.continue/rules.md

T1: Detect

test -f .cursorrules && echo "cursor: .cursorrules"
test -f .github/copilot-instructions.md && echo "copilot: .github/copilot-instructions.md"
test -d memory-bank/ && echo "cline: memory-bank/"
test -f .continue/rules.md && echo "continue: .continue/rules.md"

T2: Ask user

List found files, ask which to import (numbers, comma-separated, or "all"). If none found:

No competing tool configuration files found.
Checked: .cursorrules, .github/copilot-instructions.md, memory-bank/, .continue/rules.md

T3: Run import

For each selected tool:

python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" <tool> --path <file>

Tools: cursorrules, copilot, cline, continue.

T4: Report

Imported <N> memories into <project_id> (cursor: <N>, copilot: <N>)

Notes: infer=False, tagged metadata.source=<tool>-import, sections <50 chars skipped, chunks >10k chars truncated, safe to re-run (deduplication handles it).

---

Importing Claude Code's native MEMORY.md

When invoked with a path to Claude Code's native MEMORY.md file (typically ~/.claude/projects/<proj-key>/memory/MEMORY.md), or when on_session_start.sh detects native auto-memory and the user chooses to import:

1. Read the file. It contains newline-separated memory entries (one fact per line, sometimes with - bullet prefix).
2. Split by non-empty lines. Each line becomes one memory.
3. Skip lines shorter than 20 characters or lines that are just headers (#).
4. For each line, call add_memory with:
   • text="<line>"
   • user_id=<active_user_id>
   • app_id=<active_project_id>
   • metadata={"type": "task_learning", "source": "memory-md-import", "confidence": 0.8}
   • infer=False
5. Report: Imported <N> memories from MEMORY.md into project <project_id>
6. Suggest disabling native auto-memory:

   To avoid duplicate memory systems, add to ~/.claude/settings.json:
     "autoMemoryEnabled": false
   

This handles the cold-start gap when a user has been using Claude Code's native memory and switches to mem0.

Error Handling

• If the parser script is not found at <PLUGIN_ROOT>/scripts/parse_export_file.py, print an error and stop.
• If add_memory calls fail consistently (e.g. auth error), report the issue and stop early.