---
title: "Importação"
description: "Importe conversas do Claude e do ChatGPT, memória MCP, projetos do Claude e Markdown puro — com detecção de formato pelo conteúdo."
---

# Importação

A importação puxa uma base de conhecimento já existente para dentro de um espaço em um único upload: exportações do claude.ai e do ChatGPT, um memory-server MCP, projetos e memória do Claude, além de arquivos Markdown e de texto simples. O formato é detectado **pelo conteúdo**, e não pelo nome do arquivo, então você não precisa preparar nada à mão — o próprio motor desmonta o pacote e o distribui em pastas.

A importação é o espelho da [exportação](/docs/import-export/export/): a exportação lê do disco os arquivos que são a fonte da verdade; a importação analisa a origem e grava as notas pelo caminho de escrita normal. Cada nota chega ao espaço exatamente como se um humano a tivesse criado no editor — com versionamento, proveniência e indexação.

## Quais formatos ela entende

Um único pacote do Claude ou do ChatGPT costuma trazer vários tipos de dado ao mesmo tempo; a importação detecta e traz tudo o que sabe tratar:

| Origem | Arquivo na exportação | O que vira nota |
|---|---|---|
| Conversas do Claude | `conversations.json` | Uma nota por conversa, mensagens como `### Human/Assistant` |
| Conversas do ChatGPT | `conversations.json` (inclusive fragmentado em `conversations-000.json…`) | Uma nota por conversa, transcrição em ordem cronológica |
| Memória MCP | `memory.json` (JSONL) | Uma nota por entidade; relações → `[[wikilinks]]` |
| Projetos do Claude | `projects.json` ou `projects/<uuid>.json` | Uma pasta de projeto: documentos + instruções |
| Memória do Claude | `memories.json` | Uma nota por bloco de memória da conta |
| Design chats do Claude | `design_chats/<uuid>.json` | Uma nota por chat |
| Markdown / texto | `.md`, `.txt` | Uma nota, o corpo do arquivo = o corpo da nota |

O formato é definido pela análise do conteúdo (todo serviço entrega um arquivo chamado `conversations.json`, então o nome não é confiável). Mensagens vazias e conversas sem um único trecho com conteúdo não geram notas "órfãs" — quantas foram ignoradas aparece no resumo da importação. Se dentro do pacote vier um JSON que não é reconhecido, ele também vai parar no resumo, como `unsupported` — a perda de dados sempre aparece no resumo, em vez de acontecer sem ninguém ver.

## Como importar

A importação fica na aba **Import** nas configurações do espaço (`/s/<space>/management/import`). Cada opção é uma seção própria:

- **File** — escolha o arquivo da exportação (`conversations.json`, o ZIP inteiro da exportação ou `memory.json`). Um arquivo `.md`/`.txt` avulso entra por arrastar e soltar (veja abaixo), não por esse diálogo.
- **Skip existing notes** — o que fazer numa importação repetida (veja abaixo).
- **Memory entries** — onde colocar as entidades de memória (veja abaixo).

Uma importação demorada roda como **tarefa durável**: barra de progresso com contador ao vivo de notas gravadas, a fase atual e um botão **Cancel**. Dá para sair da aba e voltar — a importação segue rodando em segundo plano e, na volta, você vê o progresso de novo ou o resumo final.

> [!tip] Solte um arquivo na janela
> O diálogo de upload separado é opcional: solte um arquivo `.md` ou `.txt` direto na janela do app e ele vira uma nota. Soltar sobre uma pasta da árvore guarda a nota ali; soltar na área de conteúdo guarda a nota na pasta da nota aberta, ou na raiz. É o mesmo pipeline de importação, só que por outra porta de entrada.

### A opção "Skip existing notes"

O nome do arquivo de uma nota é determinístico e amarrado à identidade da origem. Por isso, reimportar a mesma exportação **sobrescreve os mesmos arquivos** em vez de multiplicar duplicatas — e cinquenta conversas "Untitled" não se atropelam.

- **Desligada (o padrão para reenvios — upsert)** — as notas existentes são sobrescritas por caminho, de forma idempotente.
- **Ligada** — notas cujo caminho já existe são **ignoradas**. É o caso "reimportei o histórico atualizado — não passe por cima do que eu já ajustei à mão".

### A opção "Memory entries"

As entidades de `memory.json` podem ir para um de três lugares:

- **folder** — notas visíveis, voltadas ao usuário, sob a pasta raiz da importação.
- **space** — para o mount oculto de memória do agente do espaço (`.notarium/memory`): essas entradas não aparecem na árvore, no Feed nem na busca, mas o agente chega até elas via `recall`.
- **skip** — não importar a memória de jeito nenhum.

> [!note] Memória do espaço, não o domínio global
> A opção **space** coloca as entradas na memória do agente daquele espaço específico. Não existe um navegador de UI separado para essa memória dentro do espaço — o agente a enxerga pelo `recall`. É a memória de um espaço específico, não o domínio global de memória pessoal (que abre como a lente **Memory** na árvore do explorador) — e esta importação não escreve nesse domínio.

## Como os dados são organizados

A importação cria uma árvore de pastas previsível dentro da raiz escolhida:

```md
conversations/claude/      — conversas do Claude
conversations/chatgpt/     — conversas do ChatGPT
projects/<projeto>/        — projetos do Claude (+ docs/, prompt-template.md)
memory/claude/             — memória da conta Claude
memory/<tipo-de-entidade>/ — entidades de memory.json
design-chats/<projeto>/    — design chats do Claude
```

## As datas são preservadas como dados

Uma importação ingênua dataria todo o histórico como "hoje", e o Feed empilharia centenas de conversas num monte só. Em vez disso, o Notarium **leva a data de criação adiante como dado**: cada nota recebe no frontmatter um `created:` com o momento em que a conversa realmente aconteceu. O Feed espalha o histórico importado pelos dias reais, e o ciclo exportação → importação preserva as datas — nada se perde na mudança.

O campo "Created" também pode ser editado à mão pelo editor (nos metadados da nota) — numa migração, por exemplo, ou para acertar a data de uma nota. Já o horário da última modificação (`modified`) sempre reflete quando o arquivo foi de fato editado, e esse não dá para mudar.

## Como funciona por baixo dos panos

A importação foi feita para aguentar tanto pacotes de vários gigabytes quanto uma conexão que cai:

- **Processamento em streaming.** O upload é gravado no disco em streaming, o ZIP é descompactado um membro por vez e o array JSON de conversas é analisado elemento a elemento — uma conversa de cada vez. O pico de memória não depende do tamanho do pacote, então uma exportação de 600 MB não derruba o servidor.
- **Tarefa durável.** Quando o host tem um banco de metadados (a norma na auto-hospedagem), a importação roda por padrão como tarefa durável: o upload é salvo em staging e um worker em segundo plano grava as notas fora da requisição. Aba fechada, conexão perdida, até um reinício do servidor — nada disso custa progresso.
- **Cooperatividade.** Uma importação em massa não monopoliza o servidor: a gravação dá passagem às requisições interativas, e a indexação em segundo plano pausa enquanto o fluxo corre e recupera o atraso depois. Busca e navegação continuam responsivas mesmo com milhares de notas sendo gravadas.

```mermaid
flowchart LR
  src([Pacote / arquivo]) -->|upload| stage[Staging no disco]
  stage -->|tarefa de importação| worker[Worker em segundo plano]
  worker -->|caminho de escrita| notes[(Notas Markdown)]
  worker -.->|progresso| ui([Aba Import])
```

> [!note] Importação sem banco de metadados
> Num host sem banco de metadados (e ele só está ausente no modo `AUTH_MODE=none`) não existe camada de tarefas: a importação segue o caminho síncrono de streaming dentro de uma única requisição, com o mesmo núcleo e o mesmo contador ao vivo. Progresso e resumo têm a mesma cara; a única diferença é que a importação não sobrevive a um reinício do servidor.

## Limites

- **Cancelar, mas não pausar.** Dá para cancelar uma tarefa (de forma cooperativa), mas não pausar e retomar.
- **O indicador é indeterminado.** Não se sabe de antemão quantas notas há no pacote, então o progresso mostra a fase e um contador ao vivo de notas gravadas, e não porcentagem e ETA.
- **Upload interrompido recomeça do zero.** A durabilidade só entra em cena depois que os bytes chegaram: se o envio de um pacote grande for cortado, ele começa de novo.
- **Anexos binários não são importados.** O texto dos anexos vai embutido no corpo da nota; os arquivos binários em si, não (igual na exportação).
- **A importação cai na raiz do espaço.** O diálogo de importação não deixa escolher a pasta de destino — as notas vão para a raiz; no arrastar e soltar, a raiz é definida pela zona onde você soltou o arquivo.

## A seguir

- [Exportação](/docs/import-export/export/) — leve um espaço ou uma pasta de volta em um pacote de arquivos Markdown.
- [Agentes e MCP](/docs/agents/) — como um agente trabalha com a memória importada via `recall`.
