---
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`:

```bash
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

Read the export file directly. It is a JSON file containing a top-level `memories` array. 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

Parse the JSON in-memory (do not run any external script). If the file cannot be read or parsed, or if the `memories` array is missing or empty, 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` (MCP tool) 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.
- 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

```bash
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: Import

For each selected tool, read the file(s) directly and split the content into logical
chunks to import as individual memories. No external scripts are used — all parsing
and importing is done via MCP tools.

Chunking rules per tool:

- **cursorrules / copilot / continue**: Read the file as plain text. Split on blank
  lines or section headers (`#`, `##`). Each non-empty chunk becomes one memory.
  Skip chunks shorter than 50 characters.

- **cline (memory-bank/)**: List all `.md` files in the directory. Read each file.
  Split each file on blank lines or headers. Each non-empty chunk becomes one memory.
  Skip chunks shorter than 50 characters.

For each chunk, call `add_memory` (MCP tool) with:
- `text="<chunk text>"`
- `user_id=<active_user_id>`
- `app_id=<active_project_id>`
- `metadata={"type": "task_learning", "source": "<tool>-import", "confidence": 0.8}`
- `infer=False`

Where `<tool>` is `cursorrules`, `copilot`, `cline`, or `continue`.

Notes: chunks longer than 10,000 characters are truncated before import. Safe to
re-run — deduplication handles repeated entries.

### T4: Report

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

---

## 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 directly. 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` (MCP tool) 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 `add_memory` calls fail consistently (e.g. auth error), report the issue and stop early.

## Output formatting

IMPORTANT: Do NOT use markdown in your output. OpenCode TUI renders text verbatim — markdown like **bold**, ## headers, and | table | syntax appears as raw characters. Use plain text with indentation for structure. Use dashes for lists. Use spaces to align columns instead of markdown tables.