Mem announced on November 16 that it is shutting down. The dates are short: notes go read-only on December 18, 2026, and the service is gone on January 15, 2027. Mem's own shutdown note and migration guide are clear and honest, and the export tooling looks better than most shutdowns get.
The reaction on X was quick and mostly the same line: every AI second brain that lives on someone else's server has a shutdown date; Markdown files on your own disk don't. That's true, and it's also only half the story. If you used Mem the way it was sold, as "the notes app that thinks alongside you," most of the value was never in the files. It was in what the app worked out from the files.
This post is for anyone moving off Mem this month, and for anyone building an LLM wiki or AI second brain who would like their own exit to be boring. It covers what the export actually contains, a script to check it before you trust it, and a short test for choosing where the notes go next.
What you actually get in the ZIP
Per Mem's save-a-copy guide, the Markdown export (Settings → Exports → Start new export → My Computer) unpacks to:
| Path | Contents |
|---|---|
notes/ |
One Markdown file per exported note |
collections/ |
One index per collection, linking to its notes. A note in two collections shows up in both indexes |
attachments/ |
Files your notes reference, linked relatively |
export-report.md |
If present, the items Mem couldn't include. Read this first |
Two details from the docs are easy to miss. Meeting transcripts are included by default, but audio recordings are a separate option you must select before starting the export. And if you keep editing in Mem after your first export, you need to export again; the ZIP is a snapshot, not a sync.
An AI second brain is three layers, and exports carry one and a half
It helps to be precise about what "my second brain" means in an AI notes tool. There are three layers:
- Sources: the notes, files, and transcripts you put in.
- Structure: links between notes, collections, tags. Some of it you made, some the app suggested.
- Derived: the search index, embeddings, "resurface this when it's relevant" features, chat over your notes.
A Markdown export carries layer 1 well. It carries layer 2 partly: links survive if they are written as relative links, and collections survive as index files rather than as properties of the note. Layer 3 does not survive in any app-independent form, because it's an index, not data. That's fine, as long as you can rebuild it from layers 1 and 2. The real migration job is making sure you can.
Step 1: Export now, not on December 17
Read-only on December 18 still lets you export, so this isn't a panic. But a large library takes time to prepare, Mem asks you to let one export finish before starting another, and you want time to find out what's missing while support is still answering email. Export once now, verify it, then do a final export after your last edit.
Keep the original ZIP untouched. Do everything below on a copy of the extracted folder.
Step 2: Verify the export with a script, not by scrolling
Mem's own advice is to open a note you know well, follow a link, and open an attachment. Do that. Then run something that checks every note, because broken relative links and orphaned attachments don't show up when you spot-check five favourites.
#!/usr/bin/env python3
"""Sanity-check an extracted Mem Markdown export before you trust it.
Usage: python3 check_export.py /path/to/extracted-export
"""
import re
import sys
from collections import defaultdict
from pathlib import Path
from urllib.parse import unquote
root = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
notes = sorted((root / "notes").rglob("*.md"))
indexes = sorted((root / "collections").rglob("*.md"))
index_set = set(indexes)
# Markdown links and images: [text](href) / 
LINK = re.compile(r'!?\[[^\]]*\]\(<?([^)\s>]+)>?(?:\s+"[^"]*")?\)')
SCHEME = re.compile(r"^[a-z][a-z0-9+.-]*:", re.I)
def local_links(md_file):
text = md_file.read_text(encoding="utf-8", errors="replace")
for m in LINK.finditer(text):
href = unquote(m.group(1).split("#", 1)[0])
if href and not SCHEME.match(href):
yield href, (md_file.parent / href).resolve()
broken = []
membership = defaultdict(set) # note path -> collection names
for f in notes + indexes:
for href, target in local_links(f):
if not target.exists():
broken.append((f.relative_to(root), href))
elif f in index_set and target.suffix == ".md":
membership[target].add(f.stem)
no_collection = [n for n in notes if n.resolve() not in membership]
multi = [n for n, c in membership.items() if len(c) > 1]
print(f"notes: {len(notes)} collection indexes: {len(indexes)}")
print(f"broken local links: {len(broken)}")
for src, href in broken[:25]:
print(f" {src} -> {href}")
print(f"notes in no collection: {len(no_collection)}")
print(f"notes in 2+ collections: {len(multi)}")
report = root / "export-report.md"
print("export-report.md:", "PRESENT, read it" if report.exists() else "not present")
What you want to see: a note count close to what Mem showed you, zero broken links, and either no export-report.md or one whose items you have consciously accepted. If your export uses [[wikilinks]] instead of standard Markdown links, extend the regex before trusting the zero.
Step 3: Move implicit structure into the files
Collections are the part most likely to get lost in the next import. Some apps turn index files into pages, some into tags, and some ignore them. The safest move is to write each note's collection membership into the note itself, as front matter, so any tool that reads YAML keeps it:
import json
# Append to check_export.py. Run on a COPY of the export.
for note, cols in membership.items():
text = note.read_text(encoding="utf-8")
if text.startswith("---\n"):
print(f"skip (already has front matter): {note.relative_to(root)}")
continue
# A JSON list is valid YAML flow syntax and safely quotes odd names.
header = f"---\ncollections: {json.dumps(sorted(cols))}\n---\n\n"
note.write_text(header + text, encoding="utf-8")
Now the structure travels with the note instead of living in a side file that the next importer may or may not understand. The same principle applies to anything you rely on: if it matters, it should be in the Markdown, not inferred from where the file sits.
Step 4: Treat the AI layer as disposable, then prove it
This is the design lesson worth keeping after Mem is gone. In a healthy AI second brain, the files are the source of truth and everything the AI knows is a cache that can be thrown away and rebuilt:
Concretely, once your notes land somewhere new:
- Rebuild search and embeddings from the folder, not from anything exported out of the old app's AI features.
- Spot-check with questions you asked the old tool. If chat over your notes used to answer "what did we decide about the pricing page in March?", ask the same question in the new setup. Failures here usually point at a missing transcript or attachment, not at the model.
- Don't migrate AI-generated summaries as if they were notes. If you saved them, keep them tagged as generated so a future agent doesn't treat yesterday's summary as a primary source.
If you've been following the LLM wiki pattern that has been all over X lately (raw sources, a wiki the agent compiles, and a schema it follows), you already have this split. The raw layer is the part you protect; the compiled wiki can be regenerated. We wrote up how to build an AI second brain around the same idea.
Choosing the next home: run the exit drill first
The most useful thing to take from this week isn't "pick a better vendor." Every vendor can stop. It's "pick a home whose exit you've already tested." Before you commit years of notes to anything new, run this drill once:
- The export runs without a support ticket, and produces open formats (Markdown, plain files) rather than a proprietary bundle.
- Links and attachments resolve in the exported folder when opened with a plain editor.
- Structure lives in the files (front matter, tags, links), not only in the app's database.
- The AI index rebuilds from the files in a fresh install, with no access to the old account.
- There is a path that doesn't depend on the company at all: the code is open, or you can self-host it, or both.
That last point is why many people moving off Mem are looking at open, local-first tools rather than another hosted AI notes app. Disclosure: I work on AFFiNE, which is in that category: an open source Notion alternative that stores data locally first and can be self-hosted. Whatever you choose, apply the same drill. A knowledge base software choice is a multi-year commitment, and "open source" only helps if you've actually tried running it without the vendor.
For teams, the AI part deserves the same scrutiny as the storage. If the AI knowledge base software you pick sends every note to a model you don't control, the files may be portable but the thinking isn't. Running the model side as self-hosted AI gives you the same exit property for the derived layer that Markdown gives you for the sources.
The short version
- Export from Mem now, verify with a script, and export again after your last edit. Tick the audio option if recordings matter.
- Write collection membership into front matter before importing anywhere.
- Rebuild the AI layer from your files; don't try to carry it.
- Before trusting the next tool, run its exit drill on day one, not on its shutdown day.
Mem's team handled this better than most. The next shutdown might not come with five weeks of notice, so it's worth doing the drill while it's still optional.



Top comments (0)