Workflow·Memory & Knowledge

Importing ChatGPT Memory

Name: Importing ChatGPT Memory
Author: letta-ai

Clone ChatGPT saved memory into Letta, then optionally enrich it with broader conversation history.

You say

Buy it · $49 Read it before you buy $49 Written by letta-ai · unverified publisher

Context cost: 26k tokensestimated from the bundle, loaded when it triggers
Bundle: 10 files · 103.9 kB7 scripts among them — read before you run
Licence: MITpaid listing
Last change: —no release on file
Servers it uses: Noneruns standalone

What it does

Clone ChatGPT saved memory into Letta, then optionally enrich it with broader conversation history. Designed for a slick onboarding flow that extracts hidden saved-memory/context blocks, builds Letta-ready previews, and only asks questions at meaningful checkpoints.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Workflow

Runs a procedure end to end.

memorymigrationlettachatgpt

Filed under

Memory & Knowledge

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md32.8 kB · 713 lines

--- name: importing-chatgpt-memory description: Clone ChatGPT saved memory into Letta, then optionally enrich it with broader conversation history. Designed for a slick onboarding flow that extracts hidden saved-memory/context blocks, builds Letta-ready previews, and only asks questions at meaningful checkpoints. license: MIT ---

7# Cloning ChatGPT Memory into Letta

9Use this skill when a user wants Letta to inherit ChatGPT memory as faithfully as possible without blindly importing an entire export.

11## Good fits

13- clone my ChatGPT memory into Letta

14- inspect hidden saved profile / custom-instruction context

15- migrate ChatGPT memory into active Letta memory

16- enrich the clone with work context or collaboration preferences from old chats

17- preserve selected transcripts for high-fidelity audit/reference

19The skill should work well even when the user says something minimal like:

20- "I want to import my ChatGPT memory"

21- "Can you clone my ChatGPT memory into Letta?"

22- "Import my ChatGPT export"

24Do **not** depend on the user writing an optimized prompt.

26## Scope

28This skill is for **memory onboarding**, not just transcript rendering.

30It should:

31- extract ChatGPT saved memory and editable-context blocks first

32- build a Letta-oriented preview of what should become active vs progressive memory

33- write obvious, high-confidence items while narrating progress

34- optionally enrich from the broader archive afterward

35- optionally export transcripts for high-fidelity archival

37It should **not**:

38- blindly import the whole archive

39- treat runtime context as durable memory

40- flatten historical context into always-visible memory by default

41- auto-store sensitive personal material without confirmation

42- write memory into a malformed MemFS structure

44## Default posture

46Use a **clone first, enrich second** workflow.

481. ask a short structured intake

492. inspect the export

503. extract and preview in one step

514. write obvious high-confidence items while learning

525. continue into archive enrichment if scoped — narrate progress, let the user interrupt

536. ask only at meaningful checkpoints

547. run /doctor to validate the final memory structure

56Users should feel like they are being guided through an onboarding flow, not dropped into a bag of scripts.

58The onboarding should be robust to sparse user input. The agent should supply the structure, not ask the user to craft a better request.

60**This skill is a workflow, not reference material.** Follow the numbered steps in order. Read the guidance for each step before executing it — especially the merge rules and write targets. Moving fast is good; skipping steps is not. "Autonomous" means you drive the process without stopping for permission, not that you skip the instructions.

62## Interaction style

64### Start with a short dialog

66When available, prefer the structured **AskUserQuestion** flow so the import feels like a dialog.

68Good question types:

69- export location (if not obvious)

70- import scope (saved memory only, memory + work context, full history mining)

71- topic focus: "Any specific projects or topics you want me to look for?"

72- sensitivity: "Anything I should avoid storing?"

74Do **not** ask about review cadence. Most users don't have a strong preference, and the ones who do will say so. Default to keeping going — narrate what you're doing and let the user interrupt if they want to pause. This keeps the flow moving instead of creating a false checkpoint.

76Avoid questions that don't actually change the workflow. For example, "how do you want historical context handled?" sounds meaningful but the answer rarely changes what scripts you run. Focus on questions whose answers fork the process.

78This intake exists so the user does **not** need to front-load all of this context in their first message.

80Use:

81- **single-choice** for policy decisions

82- **multi-select** for scope selection

84### After intake, drive the process

86Once scope is clear, be more authoritative than permissive.

88Do **not** keep returning with vague prompts like:

89- "what do you want me to do next?"

90- "should I keep going?"

92Instead:

931. say what you wrote

942. say what you are reviewing next

953. continue automatically

97Only stop for:

98- contradictory facts

99- sensitive/intimate material

100- major scope changes

101- real uncertainty about what counts as durable memory

102

103Do **not** stop for low-risk routing decisions once the user's scope is already broad and clear.

104

105Also do **not** respond by teaching the user how they should have phrased the request. Just run the onboarding properly.

106

107## Progress tracking

108

109This import can take multiple minutes for large archives. **Never let the user sit in silence.** The import should feel like a guided, living process.

110

111### Record the starting commit

112

113Before writing any memory, record the current HEAD of the memory repo:

114

115```bash

116git -C "$MEMORY_DIR" log --oneline -1

117```

118

119Save this commit hash — it's the rollback point. If anything goes wrong or the user wants to undo the import, they can reset to this commit:

120

121```bash

122git -C "$MEMORY_DIR" reset --hard <start-commit>

123git -C "$MEMORY_DIR" push --force

124```

125

126Include both the start and end commit hashes in the import audit file and in the final summary. Tell the user explicitly: "If you want to undo any of this, I can reset your memory to where it was before the import."

127

128### Use TodoWrite for phases

129

130Create a todo list at the start of the import and update it as you go:

131

1321. Record starting commit

1332. Locate export and run inventory

1343. Extract and preview saved memory

1354. Write active memory (system/human.md)

1365. Write import audit + progressive memory (reference/chatgpt/)

1376. Archive enrichment (if scoped)

1387. Validate with /doctor

139

140Mark each phase in_progress before starting and completed when done.

141

142### Narrate between script calls

143

144After each script completes, tell the user what you found before running the next one:

145

146- "Found 347 conversations spanning 2023–2026. Extracting saved memory now..."

147- "ChatGPT remembered 12 facts about you across 4 fields. Building the preview..."

148- "Writing 8 high-confidence items to active memory. Next: archive enrichment..."

149- "Dispatching 4 mining agents across 200 conversations..."

150

151### Report stats

152

153Surface concrete numbers whenever you have them:

154- total conversation count

155- saved-memory field counts

156- how many items written vs held for review

157- mining progress (conversations scanned, findings per chunk)

158

159### Use --progress on scripts

160

161All long-running scripts support --progress which prints status to stderr. Use it for large archives so the user sees work happening even during script execution.

162

163## Workflow

164

165### 0. Locate the export

166

167ChatGPT exports are typically named with a long hash and timestamp, e.g.:

1688a8f3ee0...-2026-03-31-18-41-51-e0dc362a....zip

169

170Common locations:

171- ~/Downloads/ (most common — this is where the browser saves it)

172- Desktop or a custom export folder

173

174If the user doesn't know the exact path, glob for zip files in Downloads:

175

176```bash

177ls -t ~/Downloads/*.zip | head -20

178```

179

180Downloads folders are often crowded. ChatGPT exports follow a distinctive pattern — look for filenames matching [8+ hex chars]-YYYY-MM-DD-*. A quick filter:

181

182```bash

183ls ~/Downloads/*.zip | grep -E '[0-9a-f]{8}.*-[0-9]{4}-[0-9]{2}-[0-9]{2}-'

184```

185

186If still ambiguous, check whether the zip contains conversations-*.json entries:

187

188```bash

189unzip -l <candidate.zip> | grep conversations-

190```

191

192### 1. Inventory the export

193

194Start by listing conversations and surfacing hidden-context-heavy candidates.

195

196```bash

197python3 scripts/list-conversations.py <export.zip>

198python3 scripts/list-conversations.py <export.zip> --sort hidden --min-hidden 1

199python3 scripts/list-conversations.py <export.zip> --json --limit 50

200```

201

202Use this to understand scale, find likely memory-heavy conversations, and decide whether broader archive review is even necessary.

203

204**Warning:** For large archives (300+ conversations), --json output can easily exceed 100K characters and flood your context window. Mitigations:

205- Use --limit 50 to start — you can always paginate with --start-index

206- Pipe to a file and read selectively: ... --json > /tmp/conversations.json

207- Use --title-contains to filter before dumping JSON

208- The non-JSON (table) output is much more compact for initial inventory

209

210### 2. Extract and preview in one step

211

212Use the preview builder directly on the zip — it runs the extraction internally:

213

214```bash

215python3 scripts/build-memory-preview.py <export.zip>

216python3 scripts/build-memory-preview.py <export.zip> --output /tmp/chatgpt-memory-preview.md

217python3 scripts/build-memory-preview.py <export.zip> --progress

218```

219

220This combines what was previously two steps (extract → preview) into one. It pulls the highest-signal onboarding inputs from the entire export:

221- about_user_message

222- about_model_message

223- user_profile

224- user_instructions

225

226And categorises them into:

227- **Active memory candidates** — what should be in-context every turn

228- **Runtime context** — timezone, location, current date (skip these)

229- **Historical/progressive candidates** — older versions, previous profiles

230- **Contradictions** — fields with multiple versions that need review

231

232If you need the raw extraction JSON separately (e.g. for subagent dispatch or audit), use extract-saved-memory.py directly:

233

234```bash

235python3 scripts/extract-saved-memory.py <export.zip> --json --output /tmp/chatgpt-saved-memory.json

236```

237

238**Note:** For users with simple ChatGPT profiles (e.g. just a name and one-liner), the preview mostly reformats what's already obvious. In those cases, read the preview output and go straight to writing memory. The preview is most valuable when the profile has contradictions, multiple historical versions, or a mix of durable and runtime context.

239

240### Merging with existing memory

241

242If system/human.md or system/persona.md already has content, **you are merging, not replacing**.

243

244**Anti-pattern:** Reading the existing block, then doing a str_replace that swaps the entire content for a new version. This is overwriting, even if you read first. The existing content was written by the user or a previous session — it has context you don't have. Don't throw it away.

245

246**Correct pattern:** Use targeted str_replace calls that add new lines or sections to the existing file. Concretely:

247

2481. Read the existing block (it's already in your system prompt)

2492. Identify what's **missing** — facts from ChatGPT that the existing block doesn't cover

2503. Use str_replace to insert the missing facts into the appropriate section, or append a new section at the end

2514. **Never replace a line that already exists** unless the ChatGPT data is explicitly newer and contradicts it

252

253Example — if system/human.md already says "Works at Letta" and ChatGPT saved memory says "Works at Letta on agent infrastructure", the merge is:

254```

255str_replace "Works at Letta" → "Works at Letta on agent infrastructure"

256```

257Not: replace the entire file with a rewritten version.

258

259If the existing block is empty or minimal (just the default template), a full write is fine. The merge discipline applies when there's existing content worth preserving.

260

261### Serialise memory writes

262

263**Do not create or update multiple memory files in parallel.** The memory tool can hit race conditions when called concurrently, producing spurious errors even when the writes succeed. This makes it hard to know what actually landed.

264

265Write memory files one at a time. The speed difference is negligible — memory writes are fast. The reliability difference is not.

266

267### Safe write targets and memory structure

268

269Before writing memory, inspect system/ and the relevant reference directories.

270

271Important MemFS rule:

272- **Never create overlapping file/folder paths** such as system/human.md and system/human/... or system/persona.md and system/persona/....

273

274Write targets (all imports should produce at least the first two):

275- system/human.md — condensed durable user facts and collaboration preferences that should be in-context every turn

276- reference/chatgpt/import-YYYY-MM-DD.md — **always create** — import audit trail, exclusions, uncertainty notes, source path

277- reference/chatgpt/work-and-technical-background.md — create when historical work context is found

278- reference/chatgpt/collaboration-preferences.md — create when detailed interaction/style patterns are found

279- reference/chatgpt/transcripts/ — curated transcript exports for fidelity/auditability

280

281If system/human.md already exists, update that file instead of inventing a sibling folder.

282If system/persona.md already exists, update that file instead of inventing a sibling folder.

283

284Use progressive disclosure aggressively: keep active memory small, and link outward with [[reference/chatgpt/...]] paths so future agents can discover the archive.

285

286### 3. Write memory — active AND progressive

287

288This step writes to **both** system/ and reference/chatgpt/. Not just active memory. The progressive memory layer is where the import's long-term value lives — without it, historical context, audit trails, and collaboration preferences are lost.

289

290#### 3a. Active memory (system/human.md)

291

292Write immediately when the fact is explicit, current, and low-sensitivity:

293- name and stable identity basics

294- current role or project context

295- explicit response preferences from hidden saved memory

296- repeated formatting preferences

297- collaboration preferences like directness, question volume, anti-sycophancy

298

299Keep system/human.md compact. Only what should be in-context every turn.

300

301#### 3b. Import audit file (reference/chatgpt/import-YYYY-MM-DD.md)

302

303**Always create this file.** It records what happened during the import:

304- export path and conversation count

305- what was written to active memory and why

306- what was excluded and why

307- contradictions found and how they were resolved

308- what still needs confirmation

309- source of each decision (which saved-memory field, which conversation index)

310

311This is the receipt. Future agents can read it to understand where the memory came from.

312

313#### 3c. Progressive memory files

314

315Create these when the preview or enrichment surfaces material that doesn't belong in system/ but is worth keeping:

316

317- **reference/chatgpt/work-and-technical-background.md** — historical roles, past projects, technical background, older work context that's useful for understanding the user but not needed every turn

318- **reference/chatgpt/collaboration-preferences.md** — detailed interaction patterns, formatting preferences, correction patterns, anti-patterns — anything too granular for system/human.md but valuable when the agent needs to calibrate tone or style

319

320If the preview shows historical alternatives (older saved-memory versions, previous profiles), those go here too.

321

322#### 3d. Link progressive files from active memory

323

324After creating progressive memory files, add [[reference/chatgpt/...]] links in system/human.md so future agents can discover them. Example:

325

326```

327See also: [[reference/chatgpt/work-and-technical-background.md]], [[reference/chatgpt/collaboration-preferences.md]]

328```

329

330#### Writing pattern

331

332For each write:

3331. keep it small and specific

3342. tell the user what you wrote and where

3353. tell the user what you are reviewing next

3364. continue

337

338### 4. Optional archive enrichment

339

340Only after the saved-memory clone is handled, optionally mine broader conversation history for:

341- work/project context

342- collaboration patterns

343- historical background

344- other durable facts the user wants preserved

345

346#### Confirm before exhaustive mining

347

348Archive enrichment dispatches subagents — potentially many of them. For a 500-conversation archive, that's ~10 parallel agents. **Always confirm with the user before starting**, and tell them what it will cost in concrete terms:

349

350- How many conversations will be mined

351- How many subagents will be dispatched

352- That this is the expensive part of the import

353

354Use AskUserQuestion with options like:

355- **Full archive mining** — "Mine all N conversations (~X subagents). Most thorough, most expensive."

356- **Targeted mining** — "Mine conversations matching specific topics you care about. Cheaper, still good coverage."

357- **Skip enrichment** — "The saved-memory clone already captured the essentials. Stop here."

358

359Do not automatically dispatch subagents just because the user selected "full history mining" at intake. The intake scope question establishes *willingness*; this checkpoint confirms the *specific cost* now that you know the archive size.

360

361For small archives (under 50 conversations), mine directly — no subagents needed, no confirmation needed:

362

363```bash

364python3 scripts/render-conversation.py <export.zip> --index 12 --output /tmp/chatgpt-12.md

365```

366

367For archives of 50+ conversations, **use parallel chunk-based mining** (see below).

368

369#### Topic-based filtering

370

371There is no single script for topic-based discovery + rendering. Use this two-step pattern:

372

373```bash

374# Step 1: Find conversations by topic

375python3 scripts/list-conversations.py <export.zip> --title-contains "Julia" --json

376

377# Step 2: Render the most promising ones individually

378python3 scripts/render-conversation.py <export.zip> --index 95

379python3 scripts/render-conversation.py <export.zip> --index 144

380```

381

382For broader topic sweeps, try multiple --title-contains queries (e.g. "Julia", "Bayesian", "economics") and deduplicate by index before rendering.

383

384#### Stale-context / retraction sweep

385

386Before promoting historical findings to active memory, do a lightweight sweep for explicit corrections in later conversations.

387

388Use content search with --role user to focus on what the user actually said:

389

390```bash

391python3 scripts/search-conversations.py <export.zip> --query "not doing" --query "no longer" --query "forget that" --query "remove from memory" --role user

392python3 scripts/search-conversations.py <export.zip> --query "used to" --query "don't assume" --role user --json --limit 20

393```

394

395Typical signals:

396- the user says a project is no longer active

397- the user says to forget or remove old context

398- the user says a role, employer, affiliation, or plan is outdated

399

400When old context conflicts with a newer explicit correction, prefer the newer correction.

401

402### 5. Validate with /doctor

403

404After the import completes — whether it was a simple saved-memory clone or a full archive enrichment — **run /doctor**. This is not optional. It validates:

405- memory structure integrity

406- no overlapping file/folder paths

407- prompt hygiene

408- block size sanity

409

410If /doctor flags issues, fix them before declaring the import complete.

411

412### 6. Transcript preservation

413

414Transcript preservation happens **during mining**, not as a separate step afterward. When you or a subagent encounter a high-signal conversation, store it immediately — don't queue it up as a question for later.

415

416**Anti-pattern:** Do not collect transcript candidates during mining and then present them as a menu ("Which transcripts do you want me to export?"). This forces the user to make decisions about conversations they haven't read. Instead, store high-signal transcripts as you find them, mention what you stored in your progress narration, and move on. The user can always delete what they don't want — that's easier than re-mining what wasn't stored.

417

418#### Store automatically (don't ask)

419

420Preserve a conversation when it contains:

421- **Career transitions or major life decisions** — role changes, company moves, pivots. These are the user's own narration of their trajectory and are rarely redundant with memory blocks.

422- **Deep technical design discussions** — architecture decisions, system design, research methodology. The nuance matters and can't be distilled to a bullet point.

423- **Detailed project context** — goals, constraints, collaborators, timelines for projects the user worked on seriously.

424- **Explicit preference statements in context** — not just "be direct" but the full exchange where they explained *why* and *when* they want directness.

425

426For these, **summarize** into a 2–5 paragraph reference file at reference/chatgpt/transcripts/NNN-slug.md. Include a frontmatter description so the file is discoverable. Only use verbatim export when fidelity genuinely matters (exact decisions, nuanced technical context where summarizing would lose signal).

427

428#### Ask before storing

429

430- Conversations focused on health/mental health specifics, intimate relationship dynamics, or financial details

431- Conversations where the signal is genuinely ambiguous (might be useful, might be noise)

432

433#### Don't store

434

435- Conversations already fully captured by memory blocks

436- One-off tasks with no durable context

437- Conversations that are mostly assistant output with little user input

438

439#### How subagents handle transcripts

440

441Subagents should store transcripts during their mining pass, not report candidates back. The subagent prompt already assigns them reference/chatgpt/transcripts/ as a write target. When a subagent encounters a high-signal conversation in its chunk, it should:

4421. Write a summarized reference file to reference/chatgpt/transcripts/NNN-title-slug.md

4432. Note in its chunk summary that it preserved the transcript and why

4443. Continue mining

445

446The primary agent does **not** need to approve each transcript. The subagent's judgment is sufficient for the "store automatically" category above.

447

448#### Bulk archival export

449

450For users who want maximum fidelity or a complete archival copy, use export-transcripts.py:

451

452```bash

453python3 scripts/export-transcripts.py <export.zip> \

454 --indexes 229,288 \

455 --output-dir /tmp/chatgpt-transcripts \

456 --skip-empty-hidden \

457 --compact-nontext

458```

459

460This is a separate archival feature, not the default. Most imports should use the selective summarization pattern above.

461

462## Hidden context to watch for

463

464Recent ChatGPT exports often contain the clearest explicit memory in hidden system/context messages.

465

466High-signal fields:

467- metadata.user_context_message_data.about_user_message

468- metadata.user_context_message_data.about_model_message

469- content.user_profile from user_editable_context

470- content.user_instructions from user_editable_context

471

472Important distinctions:

473- the same saved-memory block may repeat across many conversations

474- some hidden messages are runtime execution context, not durable memory

475- account metadata from user.json / user_settings.json is usually audit material, not active memory (note: no script currently extracts from these files — inspect manually if needed)

476

477Examples of runtime-only context:

478- current date

479- current timezone

480- current location

481- temporary recency instructions tied to a specific export moment

482

483Examples of durable collaboration context:

484- directness / brevity preferences

485- formatting preferences

486- search-first instructions for current events

487- anti-sycophancy or anti-pedantry preferences

488

489## What belongs where

490

491### Active memory

492

493Good candidates:

494- stable identity facts

495- current role / recurring project context

496- durable response preferences

497- durable collaboration preferences

498- long-lived tool/workflow preferences

499

500### Progressive memory

501

502Good candidates:

503- historical roles or project arcs

504- previous versions of ChatGPT saved memory

505- older but still useful background context

506- selected transcript exports for fidelity / auditability

507

508### Store by default

509

510Personal details are part of knowing the user. Store them:

511- family members' names, pets, hobbies, interests

512- life circumstances, where they live, background

513- personality traits, communication style

514- personal projects, side interests, goals

515- relationship status, partner's name (the fact of it, not the dynamics)

516

517The user imported their ChatGPT memory because they want to be known. Don't exclude context they expected the agent to have.

518

519### Ask before storing

520

521Stop and confirm only for material with real consequences if mishandled:

522- **Health/mental health specifics** — diagnosis, medication, treatment details (not "handle sensitively" flags, which are fine to store)

523- **Intimate relationship dynamics** — not "has a partner named X" but conflict details, emotional specifics

524- **Financial specifics** — debt, income, specific amounts

525- **Contradictions** where the current truth is unclear

526

527The intake question about sensitivity ("anything I should avoid storing?") is the user's chance to set boundaries. If they don't flag anything, store personal details by default.

528

529## Parallel mining with subagents

530

531For archives of **50+ conversations**, use chunk-based parallel mining instead of processing everything sequentially. This is the default enrichment strategy for non-trivial archives.

532

533### How it works

534

5351. **Primary agent** handles the explicit saved-memory clone (steps 0–3 of the workflow)

5362. **Primary agent** partitions the remaining archive into chunks of ~30–50 conversations

5373. **Primary agent** dispatches one general-purpose subagent per chunk

5384. **Each subagent**:

539 - Renders its assigned conversations using render-range.py or individual render-conversation.py calls

540 - Extracts durable facts, preferences, project context, and retractions

541 - Writes findings directly to its assigned memory path (e.g. reference/chatgpt/mining/chunk-NNN.md)

542 - May write curated transcripts to reference/chatgpt/transcripts/ if warranted

543 - Returns a summary separating safe-to-promote and proposal-only findings

5445. **Primary agent**:

545 - Reads all chunk summaries from reference/chatgpt/mining/

546 - Merges high-confidence findings into system/human.md

547 - Resolves contradictions across chunks

548 - Runs /doctor to validate the resulting memory structure

549

550### Subagent design rules

551

552- **Give each subagent the full script paths** — they don't inherit your skill knowledge

553- **Limit scope to 30–50 conversations per subagent** — more risks context overflow or timeouts

554- **Use general-purpose subagent type** — these subagents need to run scripts via Bash

555- **Partition output paths up front** — each subagent owns a non-overlapping destination

556- **Allow direct progressive-memory writes** — subagents write to reference/chatgpt/mining/chunk-NNN.md and reference/chatgpt/transcripts/ directly

557- **Keep active-memory writes coordinated** — only the primary agent merges into system/human.md / system/persona.md

558- **Subagents must not modify existing memory files** — they create new files only (reference/chatgpt/mining/chunk-NNN.md, reference/chatgpt/transcripts/NNN-slug.md). They must never read, edit, or overwrite anything in system/ or any pre-existing file in reference/

559- **Always provide a fallback plan** — if a subagent fails, mine its chunk directly using list-conversations.py --title-contains followed by targeted render-conversation.py calls

560

561### Subagent prompt template

562

563Keep it compact. The subagent needs: export path, script paths, chunk range, output paths, and what to extract. Everything else is overhead.

564

565```

566Mine conversations [START]-[END] from [EXPORT_PATH] for durable memory.

567

568Render: python3 [SCRIPTS_DIR]/render-range.py "[EXPORT_PATH]" --start-index [START] --end-index [END] --output-dir /tmp/chatgpt-chunk-[N] --skip-empty-hidden --compact-nontext --skip-thoughts --progress

569

570Read each rendered conversation. Extract: user facts, project/work context, collaboration preferences, explicit retractions ("forget this", "no longer", "not doing").

571

572Write findings to [MEMORY_DIR]/reference/chatgpt/mining/chunk-[NNN].md with sections:

573- Safe to promote (high-confidence, explicit, current, low-sensitivity)

574- Proposal only (historical, uncertain, sensitive, contradictory)

575- Retractions (older context the user said to forget)

576

577High-signal conversations (career transitions, deep technical design, detailed project context, explicit preference discussions) → summarize into [MEMORY_DIR]/reference/chatgpt/transcripts/NNN-title-slug.md. Do this during mining, not after. Use 2-5 paragraph summaries, not verbatim transcripts. Include frontmatter with a description.

578

579IMPORTANT: Only create NEW files. Do not read, edit, or overwrite any existing files in the memory directory. Do not touch system/.

580```

581

582### When subagents fail

583

584Subagents can fail silently due to timeouts or context limits. If a mining subagent fails:

5851. Don't retry with the same broad scope

5862. Use list-conversations.py --title-contains directly to find relevant conversations

5873. Render 3–5 of the highest-signal ones yourself

5884. Extract what you can — partial coverage is fine

589

590## Scripts

591

592### scripts/list-conversations.py

593

594Use for archive inventory.

595

596Key features:

597- list by global index

598- sort by hidden-context count

599- filter with --min-hidden

600- emit JSON for agent workflows

601

602### scripts/extract-saved-memory.py

603

604Use when you need the raw extraction JSON (e.g. for subagent dispatch or audit).

605

606It extracts and deduplicates:

607- about_user_message

608- about_model_message

609- user_profile

610- user_instructions

611

612It also reports first/last seen timestamps and source samples.

613

614Supports:

615- --json

616- --output

617- --progress

618

619### scripts/build-memory-preview.py

620

621The primary extraction + categorisation tool. Accepts either a zip file (runs extraction internally) or the JSON output from extract-saved-memory.py.

622

623It separates:

624- likely active-memory candidates

625- historical/progressive-memory candidates

626- runtime-only context

627- contradictions / review items

628

629Supports:

630- --json

631- --output

632- --progress

633- Direct zip input (one-step: extract + preview)

634- JSON input (two-step: preview from existing extraction)

635

636### scripts/render-conversation.py

637

638Use for deep review of one conversation. Efficiently streams to the target conversation instead of loading the entire archive.

639

640Useful mining flags:

641- --skip-thoughts

642- --skip-empty-tool-messages

643- --user-only

644- --assistant-only

645

646### scripts/render-range.py

647

648Use for batch rendering during archive enrichment. Opens the zip once and renders all conversations in-process — no subprocess per conversation.

649

650Supports:

651- --output-dir (one file per conversation) or --concat-output (single file)

652- --progress (prints rendering progress to stderr)

653- Same noise-reduction flags as render-conversation.py

654

655### scripts/search-conversations.py

656

657Use when title search is not enough.

658

659Good fits:

660- stale-context / retraction sweeps

661- finding buried project mentions inside generic titles

662- locating "forget this" / "not doing this anymore" corrections

663- searching for specific phrases before choosing which conversations to render

664

665Supports:

666- --role user|assistant|tool|system — filter which message roles to search (repeatable)

667- --progress — print search progress to stderr

668- --json

669

670### scripts/export-transcripts.py

671

672Use for optional high-fidelity archival exports.

673

674Supports:

675- selected indexes or ranges

676- transcript chunking

677- optional memory-style frontmatter

678- a generated transcript index file

679

680## Final user-facing summary

681

682At the end of a run, lead with a **narrative snapshot** — a short, natural-language paragraph of what you now know about the user. This is more engaging than a categorical list and lets the user immediately see whether the import landed correctly.

683

684Then follow with the structured breakdown:

685

6861. **Snapshot** — "Here's what I know about you now" in 3–5 sentences, written as if you're introducing yourself to future-you

6872. **What ChatGPT explicitly remembered** — the raw saved-memory fields

6883. **What got cloned into active Letta memory** — what's now in system/

6894. **What was preserved as progressive memory** — what's in reference/chatgpt/

6905. **What was excluded and why**

6916. **What still needs confirmation**

6927. **Results of the /doctor validation**

6938. **Rollback info** — start commit, end commit, and how to undo: "If you want to undo the import, I can reset your memory to <start-commit>."

694

695The snapshot is the part the user actually reads. The rollback info is the safety net.

696

697## Export structure reference

698

699A ChatGPT export zip typically contains:

700- conversations-000.json, conversations-001.json, etc. (sharded conversation history)

701- shared_conversations.json

702- user.json, user_settings.json (account metadata — usually audit material, not active memory)

703- export_manifest.json

704- images, audio, and other attachments

705

706The mapping field in each conversation is a graph, not a flat message array. The scripts handle this — you don't need to parse it manually.

707

708If the user needs help obtaining their export: <https://help.openai.com/en/articles/7260999-how-do-i-export-my-chatgpt-history-and-data>

709

710## References

711

712- references/memory-import-workflow.md — condensed checklist for the import workflow

713

In the file

SKILL.md4,546 words

Files10

LicenceMIT

Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈80

always loaded

The name and description, so the model knows the skill exists and when to reach for it.

25,895

on trigger

The instruction body and 9 supporting files, read only when the skill fires.

13.0%

of a 200k window

Ten skills this size would take about 130% of the window before you open a file.

050k100k150k200k context window

26k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption

Installsnone yet

Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for

Writes filesno

Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

If this is not it

11 other skills in Memory & Knowledge

What is in the bundle

10 files, 103.9 kB on disk. Mostly text — the instructions the model reads — with 7 scripts in it that your client would run only if the instructions tell it to.

SKILL.md32.8 kB
references/chatgpt-export-notes.md3.6 kB
references/memory-import-workflow.md4.1 kB
scripts/build-memory-preview.py10.2 kB
scripts/export-transcripts.py6.0 kB
scripts/extract-saved-memory.py11.7 kB
scripts/list-conversations.py5.5 kB
scripts/render-conversation.py16.9 kB
scripts/render-range.py4.6 kB
scripts/search-conversations.py8.5 kB

What is not in it

A skill installs nothing and depends on nothing: it is a folder your client reads. This one carries 7 scripts beside the text, so the bundle is 10 files you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

$49 once

Importing ChatGPT Memory · MIT · letta-ai

one-time

Price$49 once

LicenceMIT — the author’s, unchanged by this purchase

Paid throughStripe, once, on the card you add at the checkout

Keeps workingfor good — the files are yours once they are on disk

Updatesevery update its author ships, delivered through this account

You can read the whole bundle before paying — the SKILL.md above is the product, not a preview of it. What the money buys is the delivery: the folder packaged and handed to your machine by key, every update its author ships, and our support if it does not do what this listing says. The terms of use are MIT, set by the author and unchanged by buying it here.

Payment runs through Stripe, on a page like this one rather than a redirect. Once there is an account it joins the same mcprush invoice as everything else you run, so there is never a second card to enter.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/

Claude Desktop

ChatGPT

Cursor.cursor/skills/

VS Code.github/skills/

Codex CLI.agents/skills/

Gemini CLI.gemini/skills/

Grok.grok/skills/

Zed.agents/skills/

Windsurf.windsurf/skills/

Agent SDK.claude/skills/

HTTP / API

This release

Versionnot versioned

Publishedno release date on file

Price$49

Referenceletta-ai/importing-chatgpt-memory

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

No earlier releases have been published to the marketplace.

Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

letta-ai

Publishes on mcprush.

0 servers listed2 skills listednot claimed

Profile

Publisher

Servers0