"Persiste isso": tirar uma informação do ChatGPT e levá-la para um armazenamento permanente

Trabalho com frequência vários dias dentro da mesma conversa do ChatGPT.

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

Nesse momento, eu queria simplesmente poder dizer:

Persiste isso.

E continuar trabalhando.

E cinco dias depois:

Me devolve tudo o que eu persisti.

Parece óbvio.

Mas 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 significa 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 consegue 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 alguns elementos úteis e não deve ser considerada um armazenamento exaustivo de tudo o que foi dito.

FAQ oficial sobre a memória do ChatGPT

O transcript, então, está completo para mim.

O ChatGPT, esse, não necessariamente guardou palavra por palavra os trechos que me interessam.

E é exatamente disso que eu preciso.

Se eu seleciono hoje 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 persista.

Alguns dias depois, o ChatGPT talvez reencontre o que eu tinha selecionado, e talvez seja incapaz de me devolver aquilo palavra por palavra. Não é confiável o bastante para o que eu preciso.

Quero reencontrar exatamente os trechos que decidi guardar.

É essa necessidade que justifica uma persistência externa.

Não quero salvar a conversa inteira

O objetivo definitivamente não é 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 pedaços que têm valor.

Por exemplo:

Persiste nossa última definição.

ou:

Persiste isso.

A decisão de guardar continua humana.

Primeira ideia: uma API

Meu primeiro reflexo foi clássico.

Construir um pequeno serviço PHP capaz de receber texto e acrescentá-lo a um arquivo Markdown.

Algo como:

ChatGPT
   ↓
API
   ↓
Markdown

Então desenvolvi (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 minha API

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

O ChatGPT sabe montar sozinho uma URL de API e acrescentar parâmetros nela. Mas, em alguns casos, assim que a URL foi modificada ou construída por ele, a ferramenta web se recusa a chamá-la depois. O problema, portanto, não é fabricar a URL, e sim ter o direito de executá-la.

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

Era preciso encontrar outro caminho.

Segunda tentativa: dar um jeitinho

O ChatGPT sabe consultar páginas Web.

Então tentei esconder uma operação de escrita atrás do que parecia uma simples consulta a uma página Web.

Em vez de enviar:

POST /persist

montei uma URL do tipo:

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

Para o ChatGPT, o pedido parecia apenas:

Consulte esta página Web.

Para o meu servidor:

Pegue os parâmetros e escreva tudo em disco.

Ou seja, eu transformava de propósito uma escrita em uma falsa leitura.

Não era muito elegante.

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

E do lado do servidor, funcionava.

• Pelo navegador: nenhum problema.
• Com curl: nenhum problema.

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

O que, no fim das contas, é bastante lógico.

Eu estava tentando exatamente fazer sair automaticamente conteúdo da conversa para o meu próprio servidor, disfarçando a escrita de consulta a uma página Web.

Olhar para o que o ChatGPT já sabe fazer

Foi aí que mudei a pergunta.

Em vez de procurar:

Como fazer o ChatGPT chamar 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 nova linha apareceu:

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

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

Ele existia de forma independente do ChatGPT.

O Google Sheets como caixa de saída

Não era minha arquitetura ideal.

Eu queria, no começo:

ChatGPT → API → Markdown

Agora eu tinha:

ChatGPT → Google Sheets

Mas o Google Sheets não precisa ser 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 eu posso fazer:

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

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

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 vinha do fato de o ChatGPT redescobrir quase tudo a cada vez.

• Ele procurava o arquivo.
• Ele buscava os metadados.
• Ele verificava a aba.
• Ele olhava as colunas.
• Ele procurava onde escrever.

E só então acrescentava os dados.

Só que nada disso mudava de uma chamada para outra.

Parar de procurar o que a gente já conhece

Então coloquei diretamente 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 dele. Não releia os cabeçalhos.

Faltava ainda determinar onde escrever.

Minha primeira solução era inserir sistematicamente a nova entrada 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 reler acontecem agora em um ou 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, então, 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 realmente escrito.

Então acrescentei uma regra.

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

Para um texto curto, ele mostra o que realmente releu:

Persistido ✓

Contexto: Remote Persistence Store
Status: OK

Conteúdo:
AZERTY

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

O importante é 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

É claro que eu não queria colar todo esse manual de instruções no começo de cada nova conversa.

Então coloquei 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 esses dois elementos configurados, posso começar uma nova conversa e escrever direto:

Persiste 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 vai uma versão anonimizada.

Você precisa substituir os três valores entre <...> pelos da sua própria planilha do Google. Dá para 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 troca" = persistir o conteúdo relevante da última troca.
- "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 relevante 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 já conhecidos.
3. Usar um append nativo do Google Sheets.
4. Acrescentar exatamente:

   created_at | context | content

OTIMIZAÇÃO

Durante um comando "Persiste":

- não procurar o arquivo;
- não ler os metadados dele;
- 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 já 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 de armazenar.
- Não reformular nem corrigir, a menos que seja pedido explicitamente.
- 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 diz respeito apenas à 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 focada → resposta

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

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

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

É bem mais simples que isso.

É um lugar externo no qual posso decidir que um pedaço de conversa merece ser guardado.

Durante uma discussão:

a gente procura
→ a gente testa
→ a gente reformula
→ algo se torna interessante

Nesse momento:

Persiste isso.

O pedaço sai do fluxo.

Ele fica 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 quantidade enorme de informação temporária.

Nem tudo precisa sobreviver.

Mas algumas coisas merecem passar do fluxo para algo durável.

Não quero pedir ao ChatGPT que memorize tudo.

Quero poder dizer a ele:

Isso aqui conta.

E depois:

Persiste isso.

A conversa continua sendo o espaço em que eu trabalho.

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

Para saber mais

Do arquivo único ao sistema de contextos: por que a memória de um LLM não cabe em um só documento Por baixo do capô do meu motor de contexto: como uma IA se lembra de uma missão Adicionar uma memória de sessão como no OpenClaw O entregável não é mais o capital