What is MIF (Memory Interchange Format)?

MIF is a portable, standards-aligned format for exporting and importing AI agent memory — markdown plus linked-data (JSON-LD) frontmatter projected into a knowledge graph. ZeroMemory exports and imports MIF (and the git/Obsidian-friendly Vault-LD dialect) so your memory is portable and free of lock-in.

How do I migrate memory from Mem0, Zep, or Letta to ZeroMemory?

Map each provider record to a MIF document (content + optional metadata), then POST them to the ZeroMemory import endpoint at /api/v1/public/memory/v2/import. Import runs the standard write path, so migrated memories get embeddings, entity extraction, and semantic recall automatically.

Is memory migration lossless?

Yes. Export → import is lossless within a conformance level. You can export a memory as MIF, re-import it into a different namespace, and recall it identically — so your memory is portable, not trapped in one vendor.

Can I store AI memory in git or Obsidian?

Yes. The Vault-LD format is markdown with YAML frontmatter — git-backable and Obsidian-browsable — so you can version-control and inspect your agent memory as plain files.

Memory Interchange Format (MIF)

Your agent memory is yours.

Export and import ZeroMemory in open formats — MIF and Vault-LD. Migrate from Mem0, Zep, or Letta. Export to git or Obsidian. Lossless round-trip, zero lock-in.

Start free Migrate my memory

What is Memory Interchange Format?

MIF is a portable, standards-aligned format for AI agent memory: markdown + linked-data (JSON-LD) frontmatter projected into a knowledge-graph ontology. Think of it as the CSV or PDF of AI memory — a neutral format your memory can move in and out of.

Mem0, Zep, and Letta don't implement these emerging standards yet. ZeroMemory already has the graph engine those file formats describe — so it's a drop-in destination for memory leaving other tools, and a git-backable surface for the memory you keep.

Migrate from Mem0, Zep, or Letta

Map each provider's records to MIF documents, then POST them to the import endpoint. Migrated memories get embeddings, entity extraction, and semantic recall automatically.

# 1. Map a Mem0 record → MIF
doc = {
  "@context": "https://mif.ainative.studio/context/v1",
  "@type": "Memory",
  "@id": f"urn:mif:memory:{rec['id']}",
  "content": rec["memory"],
  "conceptType": "semantic",
}

# 2. Import into ZeroMemory
POST /api/v1/public/memory/v2/import
{ "format": "mif-json", "namespace": "project:acme", "documents": [doc] }

Migrate from Mem0 →

Move your Mem0 memories in minutes.

Migrate from Zep →

Sessions + summaries, namespace-preserved.

Migrate from Letta →

Archival + recall memory blocks.

Two open formats, one model

MIF (JSON-LD + Markdown)

Linked-data documents with a stable @context, conformance Levels 1–3 (adds relationships, bi-temporal validity, provenance, and portable embeddings).

Vault-LD (Markdown)

Git-backable, Obsidian-browsable vault notes over the same canonical model. Version-control your agent memory as plain files.

No lock-in. Ever.

Import from anywhere, export to files you control. Start free — no credit card.

Get started with ZeroMemory