How to Migrate ChatGPT Memory to Cursor: 2026 Updated Guide

ChatGPT has no native push to Cursor. You'll copy ChatGPT Custom Instructions, saved Memory entries, and any coding-related Custom GPT Instructions into .cursorrules (or .cursor/rules/*.mdc) at the repo root, and translate reusable prompts into Notepads. Plan 15–25 minutes per repo. A shared MCP-based memory layer like MemoryLake lets both tools read the same source.

Three drivers in 2026:

• In-editor flow. Cursor's Tab acceptance, inline edits, and Cmd-K make round trips through a browser chat feel slow.
• Repo-aware grounding. Cursor reads your codebase by default; ChatGPT needs files attached.
• MCP and tool integration. Cursor exposes MCP servers and shell access in ways the browser ChatGPT doesn't.

Different scopes.

ChatGPT memory spans Custom Instructions (global preferences), Memory (saved facts pulled into every chat), and Custom GPTs (project-like containers with their own Instructions and Knowledge).

Cursor memory is repo-scoped first: `.cursorrules` (single-file project rules), *`.cursor/rules/.mdc` (structured per-rule format), Notepads (reusable prompts), and user-level Rules for AI** in Settings.

ChatGPT's global "respond this way" guidance becomes user-level Rules for AI. Coding-specific Custom GPT Instructions become .cursorrules content. Reusable prompts become Notepads.

ChatGPT has no single export.

1. Copy Custom Instructions. Settings → Personalization → Custom Instructions.
2. Copy saved Memory entries. Same page → Memory. Paste each row into a text file.
3. Identify coding-relevant Custom GPTs. For each one with engineering Instructions or Knowledge, copy Instructions into a folder and download original Knowledge files where you supplied them.
4. List reusable prompts. If you have go-to prompts ("refactor this function with...", "review this PR for..."), capture them into a prompts.md.

End state: a chatgpt-export-coding/ folder with custom-instructions.txt, memory.txt, per-Custom-GPT subfolders, and prompts.md.

Cursor expects per-repo configuration plus user-level Rules.

1. Translate Custom Instructions into Cursor's user-level Rules for AI. Settings → Rules for AI. Paste universal guidance.
2. Create a `.cursorrules` at each relevant repo root. Paste coding-specific Custom GPT Instructions, adapted to that repo's stack.
3. *Optionally split into `.cursor/rules/.mdc.** For richer behavior, create per-concern .mdc` files with frontmatter (description, globs, alwaysApply) and the instruction as the body.
4. Add Knowledge as repo docs. If a Custom GPT relied on uploaded reference docs, put them in a docs/ folder in the repo and reference them in .cursorrules.
5. Create Notepads from reusable prompts. Open the Notepads panel and add each prompt as a Notepad.
6. Probe. Cmd-K in a relevant file and ask the model to apply one of the moved rules.

• Global Memory behavior. Cursor's user-level Rules for AI apply everywhere but don't auto-pull arbitrary facts the way ChatGPT Memory did.
• Custom GPT Actions. API-backed Actions don't translate; rebuild as MCP servers.
• Conversational continuity. ChatGPT chat threads stay in your account; Cursor's chats live in the IDE.
• Ongoing sync. New ChatGPT memory added next week won't appear in .cursorrules unless you redo the copy.

If you still use ChatGPT for design conversations and Cursor for coding, the per-tool drift starts immediately. Worse, anything broader than a single repo lives in two places.

MemoryLake holds those rules once and exposes them through MCP. Cursor supports MCP, and you can read MemoryLake from ChatGPT via a Custom GPT Action calling its REST endpoint.

• One source of truth. Update once; both tools see the change.
• Cross-repo standards. Team conventions live above any single repo.
• Drop-in for the next tool. Add Windsurf or Claude Code later with a config change.

Step 1: Create a project and load your context

Sign in to MemoryLake, open Project Management, and click Create Project. Name it "ChatGPT ↔ Cursor shared context." Drag reference docs (style guides, ADRs as PDF, Word, Markdown, or images) into the Document Drive under My Space, then open the Documents Tab and click Add Documents. Paste your ChatGPT Custom Instructions, Memory entries, and coding Custom GPT Instructions into the Memories Tab via Add Memory.

Step 2: Generate an MCP Server endpoint

Open the MCP Servers Tab inside the project, click Add MCP Server, describe it (e.g., "ChatGPT + Cursor bridge"), and click Generate. MemoryLake returns a Key ID, a Secret, and an Endpoint URL. Copy the Secret immediately — it is shown only once.

Step 3: Point both tools at the endpoint

In Cursor's MCP configuration (e.g., .cursor/mcp.json), add a MemoryLake server entry with the endpoint URL and the Secret as a Bearer token. For ChatGPT, configure a Custom GPT Action that calls the same REST endpoint with the Bearer token to fetch project memory.