Costumo trabalhar vários dias dentro da mesma conversa do ChatGPT.

A gente conversa, reformula, abandona caminhos, e no meio de dezenas de mensagens aparece enfim um parágrafo interessante.

Nessa hora, eu queria poder simplesmente dizer:

Persiste isso.

E seguir trabalhando.

E cinco dias depois:

Me devolve tudo o que eu persisti.

Parece óbvio.

Só que o ChatGPT não funciona bem assim.

O chat não é a memória do ChatGPT

Esse é provavelmente o ponto menos compreendido.

A conversa exibida na interface pode estar completa. Eu consigo rolar as mensagens e reencontrar o que dissemos três dias antes.

Mas isso não quer dizer que o ChatGPT também disponha de todas essas mensagens palavra por palavra na hora de responder.

É preciso distinguir:

• o transcript guardado e exibido na interface;
• o que o modelo pode de fato usar para produzir a resposta;
• a memória do ChatGPT, que não guarda cada conversa palavra por palavra.

A OpenAI explica que a memória guarda certos elementos úteis e não deve ser tratada como um armazenamento exaustivo de tudo o que foi dito.

FAQ oficial sobre a memória do ChatGPT

O transcript, portanto, está completo para mim.

O ChatGPT é que não guardou necessariamente, palavra por palavra, as passagens que me interessam.

E é justamente disso que eu preciso.

Se hoje eu seleciono três parágrafos importantes, quero poder voltar cinco dias depois e recuperar exatamente esses três parágrafos.

"Bookmark isso" não basta

Eu poderia escrever:

Bookmark esse parágrafo.

Mas isso não cria um bookmark de verdade, que dure.

Alguns dias depois, o ChatGPT talvez reencontre o que eu tinha selecionado, mas pode muito bem não conseguir me devolver aquilo palavra por palavra. Não é confiável o bastante para o que eu preciso.

Quero reencontrar exatamente as passagens que decidi guardar.

É essa necessidade que justifica uma persistência externa.

Não quero salvar a conversa inteira

O objetivo não é, de jeito nenhum, copiar automaticamente cada mensagem.

Uma conversa longa contém muito material intermediário:

• perguntas;
• tentativas;
• reformulações;
• caminhos abandonados;
• respostas substituídas dez minutos depois.

Quero tirar do fluxo apenas os poucos trechos que têm valor.

Por exemplo:

Persiste a nossa última definição.

ou:

Persiste isso.

A decisão de guardar continua sendo humana.

Primeira ideia: uma API

Meu primeiro reflexo foi clássico.

Montar um pequeno serviço PHP capaz de receber um texto e acrescentar esse texto a um arquivo Markdown.

Algo como:

ChatGPT
   ↓
API
   ↓
Markdown

Desenvolvi então (ou melhor, o Claude Code desenvolveu) um pequeno Remote Persistence Store.

O servidor sabia:

• criar diferentes contextos;
• acrescentar conteúdo;
• devolver o Markdown;
• dar algumas informações sobre o estado do contexto.

Tecnicamente, tudo funcionava.

O problema estava em outro lugar.

Com o ChatGPT Plus, não dá para simplesmente chamar a minha API

Com a minha assinatura ChatGPT Plus de 20 dólares por mês, não dá para simplesmente pedir que o ChatGPT chame qualquer API externa.

O ChatGPT sabe montar sozinho a URL de uma API e acrescentar parâmetros a ela. Mas, em certos casos, assim que a URL foi modificada ou montada por ele, a ferramenta web se recusa depois a fazer a chamada. O problema, portanto, não é montar a URL, e sim ter o direito de executar essa URL.

Eu queria continuar usando o ChatGPT normalmente, inclusive pelo celular.

Então era preciso achar outro caminho.

Segunda tentativa: dar um jeitinho

O ChatGPT sabe acessar páginas web.

Tentei então esconder uma operação de escrita atrás do que parecia um simples acesso a uma página web.

Em vez de enviar:

POST /persist

montei uma URL mais ou menos assim:

https://meu-servidor.example/persist
?context=meu-contexto
&content=meu-texto

Para o ChatGPT, o pedido parecia apenas:

Acessa esta página web.

Para o meu servidor:

Pega os parâmetros e escreve tudo em disco.

Eu transformava de propósito uma escrita em uma falsa leitura.

Não era nada elegante.

Mas, para um protótipo pessoal, teria resolvido perfeitamente.

E, do lado do servidor, funcionava.

• Por um navegador: nenhum problema.
• Com curl: nenhum problema.

Mas, assim que o ChatGPT tinha que pegar o conteúdo da nossa conversa, montar dinamicamente essa nova URL e depois acessar a página correspondente, as proteções de navegação dele bloqueavam a operação.

O que, no fim das contas, faz bastante sentido.

Eu estava tentando justamente tirar automaticamente um conteúdo da conversa para o meu próprio servidor, disfarçando a escrita de acesso a uma página web.

Olhar para o que o ChatGPT já sabe fazer

Foi aí que mudei de pergunta.

Em vez de procurar:

Como fazer o ChatGPT chamar o meu servidor?

passei a procurar:

Onde o ChatGPT já sabe escrever?

No meu caso: o Google Sheets.

Criei uma planilha extremamente simples:

created_at | context | content

Depois testei:

Persiste "AZERTY"

E uma linha nova apareceu:

2026-09-12T15:20:44+02:00 | Remote Persistence Store | AZERTY

Dessa vez, o texto tinha de fato saído da conversa.

Ele existia independentemente do ChatGPT.

O Google Sheets como caixa de saída

Não era a minha arquitetura ideal.

No começo eu queria:

ChatGPT → API → Markdown

E agora eu tinha:

ChatGPT → Google Sheets

Mas o Google Sheets não precisa ser o meu armazenamento definitivo.

Ele pode simplesmente fazer o papel de uma outbox.

Uma caixa de saída na qual o ChatGPT deposita as informações que decidi guardar.

Depois disso, eu poderei fazer:

ChatGPT
   ↓
Google Sheets
   ↓
script
   ↓
Markdown
   ↓
Obsidian / Git / outra IA

O problema que importava estava resolvido: tirar da conversa uma informação precisa.

Primeira versão: quase 50 segundos

Funcionava, mas era terrivelmente lento.

Um comando simples:

Persiste "teste"

podia levar quase 50 segundos para escrever três células.

O problema era que o ChatGPT redescobria quase tudo a cada vez.

• Ele procurava o arquivo.
• Ele pegava os metadados.
• Ele conferia a aba.
• Ele olhava as colunas.
• Ele procurava onde escrever.

E só então acrescentava os dados.

E nada disso mudava de uma chamada para a outra.

Parar de procurar aquilo que já se conhece

Acrescentei então, direto na diretriz, todas as informações fixas:

• o identificador do Spreadsheet;
• o identificador do Sheet;
• o nome da aba;
• as três colunas;
• o significado de cada uma.

E, principalmente:

Não procure o arquivo. Não leia os metadados. Não releia os cabeçalhos.

Ainda faltava determinar onde escrever.

Minha primeira solução era inserir a nova entrada sempre na linha 2.

Era rápido, mas os dados ficavam então na ordem inversa: os mais recentes no topo.

Felizmente, o Google Sheets tem um mecanismo de append.

Não é mais preciso procurar a última linha.

O processo vira simplesmente:

Persiste
   ↓
append
   ↓
verificação
   ↓
resposta

Nos meus testes, as chamadas ao Google necessárias para escrever e para reler acontecem agora em um a dois segundos somados.

O tempo total de resposta do ChatGPT continua variável, mas estamos muito longe dos quase 50 segundos da primeira versão.

O problema, portanto, não era bem o Google Sheets.

O problema era que a IA redescobria a cada vez um contexto já conhecido.

Verificar depois de escrever

Eu também não queria que o ChatGPT simplesmente me mostrasse:

Está persistido.

sem saber o que tinha sido escrito de verdade.

Acrescentei então uma regra.

Depois de cada escrita, o ChatGPT precisa reler a entrada que acabou de acrescentar.

Para um texto curto, ele exibe aquilo que releu de fato:

Persistido ✓

Contexto: Remote Persistence Store
Status: OK

Conteúdo:
AZERTY

Para um conteúdo bem mais longo, ele exibe apenas um resumo fiel do conteúdo relido.

O que importa é que a confirmação venha depois da verificação.

intenção
→ escrita
→ releitura
→ verificação
→ confirmação

Deixar "Persiste" disponível em todos os meus chats

Eu obviamente não queria colar esse manual inteiro no começo de cada conversa nova.

Então coloquei tudo isso nas Instruções personalizadas do ChatGPT.

Na web:

Configurações
→ Personalização
→ Instruções personalizadas

Também é preciso conectar o Google Drive ao ChatGPT para que ele consiga acessar a planilha.

Com os dois elementos configurados, posso começar uma conversa nova e escrever direto:

Persiste a nossa última definição.

A diretriz então diz ao ChatGPT o que significa o verbo Persiste e para onde enviar o conteúdo.

Minha diretriz "PERSISTE"

Aqui está uma versão anonimizada.

É preciso substituir os três valores entre <...> pelos do seu próprio Google Sheet. Você pode pedir ao ChatGPT que encontre esses valores, ou até que crie o Google Sheet.

DIRETRIZ "PERSISTE"

Quando eu começar um pedido com "Persiste" ou pedir explicitamente para persistir uma informação, acrescente essa informação no Google Sheet configurado como store de persistência.

GOOGLE SHEET

Spreadsheet ID: <SPREADSHEET_ID>

Sheet: <SHEET_NAME>

Sheet ID: <SHEET_ID>

Estrutura fixa:

A = created_at
B = context
C = content

INTERPRETAÇÃO

- "Persiste xxx" = persistir xxx.
- "Persiste nossa última interação" = persistir o conteúdo pertinente da última interação.
- "Persiste sua última resposta" = persistir a última resposta.
- "Persiste este texto" = persistir o texto explicitamente indicado.
- "Persiste em {contexto} xxx" = usar {contexto} como context.
- Se nenhum contexto for indicado, deduzir um nome curto e pertinente a partir do assunto em curso.
- Não pedir confirmação se o pedido estiver claro.

ESCRITA

1. Determinar created_at com a data e a hora atuais.
2. Usar diretamente o Spreadsheet ID e o Sheet conhecidos.
3. Usar um append nativo do Google Sheets.
4. Acrescentar exatamente:

   created_at | context | content

OTIMIZAÇÃO

Em um comando "Persiste":

- não procurar o arquivo;
- não ler os metadados;
- não reler os cabeçalhos;
- não procurar a última linha;
- não analisar a estrutura antes da escrita;
- usar diretamente os identificadores e a estrutura conhecidos.

Só fazer uma leitura depois da escrita.

VERIFICAÇÃO

Depois do append:

1. Reler apenas a entrada acrescentada.
2. Verificar o contexto e o conteúdo.
3. Só confirmar a persistência depois dessa verificação.

CONTEÚDO

- Persistir o próprio conteúdo pedido.
- Não resumir antes do armazenamento.
- Não reformular nem corrigir, salvo pedido explícito.
- Preservar ao máximo a estrutura original.

RESPOSTA

Para um conteúdo curto:

Persistido ✓

Contexto: {context}
Status: OK

Conteúdo:
{conteúdo efetivamente relido}

Para um conteúdo longo:

Persistido ✓

Contexto: {context}
Status: OK

Resumo do conteúdo relido:
{resumo fiel em algumas linhas}

O resumo vale apenas para a confirmação.
O conteúdo armazenado continua integral.

Em caso de falha:

Persistência falhou ✗

Contexto: {context}
Status: ERRO

Problema:
{descrição curta do erro}

PRIORIDADE

append direto → verificação direcionada → resposta

Evitar qualquer operação do Google Drive ou do Google Sheets que não seja indispensável.

Isso não é uma memória para o ChatGPT

Não considero esse Google Sheet "a memória do ChatGPT".

É muito mais simples que isso.

É um lugar externo no qual eu posso decidir que um trecho de conversa merece ser guardado.

Durante uma discussão:

a gente procura
→ a gente testa
→ a gente reformula
→ alguma coisa fica interessante

Nessa hora:

Persiste isso.

O trecho sai do fluxo.

Ele passa a ser recuperável independentemente do que o ChatGPT ainda tiver em contexto daqui a cinco dias.

Do fluxo ao capital

Tecnicamente, tudo isso acaba escrevendo três células numa planilha.

Não é essa a parte interessante.

O que me interessa é o gesto.

Uma conversa com uma IA produz uma enorme quantidade de informação temporária.

Nem tudo precisa sobreviver.

Mas algumas coisas merecem passar do fluxo para algo que dure.

Não quero pedir ao ChatGPT que memorize tudo.

Quero poder apontar para ele:

Isso aqui conta.

E depois:

Persiste isso.

A conversa continua sendo o espaço no qual eu trabalho.

O que eu tiro dela pode começar a virar capital informacional.