Este artigo dá continuidade a "Persiste isso: tirar uma informação do ChatGPT e levá-la para um armazenamento permanente".

Naquela primeira gambiarra, eu tinha descoberto uma coisa bem simples, mas que mudava muita coisa: o ChatGPT conseguia escrever uma informação no Google Sheets e, portanto, tirá-la da própria janela de contexto.

Em outras palavras, eu podia dar a ele uma memória externa persistente.

Naquele momento, o Google Sheets me servia basicamente como caixa de saída.

Depois veio outra pergunta:

será que esse mesmo mecanismo bastava para rodar meu sistema de Contextos direto dentro do ChatGPT?

Por que eu queria tirar o Contexto do Mac

Faz um tempo que uso Contextos com o Codex e o Claude Code.

E quando falo em "Contexto", não estou falando apenas de um histórico de conversa ou de um lugar para guardar algumas notas.

A definição que uso é bem mais ampla:

Um Contexto é um sistema delimitado por uma missão humana, dentro do qual uma IA organiza e mobiliza o que sabemos, de onde sabemos, como os elementos se conectam e em que pé está o trabalho, para ajudar o humano a alcançar seu objetivo sem recomeçar do zero. Ao fazer isso, o sistema constitui e faz render um capital informacional duradouro: o conhecimento produzido continua disponível, se enriquece com o tempo e pode ser reutilizado para outros objetivos.

Eu já tinha construído um motor que fazia esse princípio funcionar com o Codex ou o Claude Code.

No meu Mac, funciona bem.

Do celular, eu também tinha encontrado uma solução: acessar à distância o Codex que roda no Mac.

Mas ela tem uma fraqueza bem evidente.

É preciso que:

• o Mac esteja ligado;
• ele continue conectado à Internet;
• o acesso remoto funcione.

Em casa, isso não incomoda muito.

Em campo, incomoda bem mais.

O caso que me interessava em especial era o de duas feiras profissionais que estão chegando: passar uma semana só com o celular, conversar com expositores, coletar informação, preparar entrevistas e eventualmente produzir um artigo no mesmo dia.

Eu não queria depender de um Mac ligado em algum lugar a dezenas ou centenas de quilômetros.

Então me perguntei se dava para tirá-lo completamente da equação.

O estalo: o ChatGPT já tinha quase tudo

Olhando o problema de outro jeito, percebi que um motor de Contexto precisava, no fim das contas, de três grandes blocos.

• É preciso um motor capaz de raciocinar sobre a informação.
• O ChatGPT já sabe fazer isso.
• É preciso regras que expliquem ao motor como trabalhar.
• As diretrizes de Projeto do ChatGPT podem cumprir esse papel.
• E é preciso, por fim, uma memória que sobreviva às conversas.
• Era essa a peça que faltava.

Minha arquitetura podia então virar:

Motor         → ChatGPT
Diretrizes    → Projeto ChatGPT
Persistência  → Google Sheets

O hack de persistência do meu artigo anterior fornecia justamente esse terceiro bloco.

A partir daí, levar meu motor de Contexto para dentro do ChatGPT ficou bem menos exótico.

Eu não precisava recriar um sistema completo em volta do ChatGPT.

O motor de IA já estava ali.

Faltava sobretudo dar a ele suas regras e uma memória externa que ele soubesse ler e modificar.

Como levei o motor para dentro do ChatGPT

No começo, tentei colocar todas as regras do motor direto nas diretrizes do Projeto.

Não durou muito.

As diretrizes de Projeto são limitadas a cerca de 8 000 caracteres e meu motor já precisava de bem mais.

Então separei as regras em dois níveis.

O primeiro nível é o CORE.

É a parte colocada direto nas diretrizes do Projeto ChatGPT.

Ela contém os elementos absolutamente indispensáveis ao funcionamento do motor:

• o que é um Contexto;
• onde ele fica armazenado;
• quais comandos existem;
• como abrir um Contexto;
• como persistir uma fonte;
• a estrutura dos arquivos;
• os principais invariantes;
• a hierarquia das diretrizes.

O segundo nível é uma diretriz estendida.

Ela é bem mais volumosa e vive num Google Doc.

Ela contém, por exemplo:

• o método detalhado de ingestão;
• os critérios de criação dos conhecimentos atômicos;
• a gestão do state e da synthesis;
• as decisões;
• as contradições;
• as tarefas;
• as estratégias de leitura;
• as regras de produção;
• o tratamento de erros e de casos-limite.

A hierarquia fica assim:

CORE
  ↓
Diretriz estendida
  ↓
Diretrizes próprias do Contexto

O CORE sabe onde está a diretriz estendida e manda o ChatGPT carregá-la no início de uma nova conversa.

A separação, portanto, não está ali apenas para deixar o sistema mais elegante.

Ela responde antes de tudo a uma restrição bem concreta: o motor inteiro não cabe nas diretrizes de um Projeto ChatGPT.

O Google Sheets vira a memória do Contexto

Faltava então representar o Contexto em si.

Eu poderia ter usado vários Google Docs.

• Um documento para as fontes.
• Outro para o estado.
• Outro para os conhecimentos.
• Outro para as tarefas.
• ...

Mas eu teria chegado rapidamente a um monte de arquivos para reencontrar e a outros tantos identificadores para gerenciar (vamos ver essa restrição tecnológica mais adiante).

O Google Sheets se mostrou bem mais prático.

Um Contexto corresponde a um Spreadsheet.

Dentro do Spreadsheet, cada tipo de informação tem sua aba.

Atualmente uso esta estrutura:

00-FRAME
01-STATE
03-SESSIONS
04-ATOMIC
05-OUTPUTS

00-FRAME contém principalmente a missão e as eventuais diretrizes próprias do Contexto.

01-STATE contém as informações necessárias para saber em que pé está o trabalho:

• state;
• synthesis;
• tarefas;
• decisões;
• contradições;
• handoff.

03-SESSIONS contém as fontes brutas persistidas.

04-ATOMIC contém os conhecimentos estabilizados.

05-OUTPUTS contém os entregáveis produzidos a partir do Contexto.

O Google Sheets, portanto, não é mais apenas o lugar onde o ChatGPT escreve uma informação para guardá-la.

O Spreadsheet vira a memória estruturada completa do Contexto.

Não recarregar tudo, de jeito nenhum

Isso não significa que o ChatGPT carregue o Spreadsheet inteiro a cada conversa.

Isso seria provavelmente uma péssima ideia.

Quando escrevo:

Abra Meu Contexto

o ChatGPT começa reencontrando o Spreadsheet correspondente.

Depois, ele carrega apenas o núcleo:

• missão;
• diretrizes;
• state;
• synthesis;
• tarefas;
• decisões;
• contradições;
• handoff.

As fontes, os conhecimentos atômicos e os outputs antigos ficam no Sheet.

O ChatGPT vai buscá-los só quando eles se tornam necessários.

Esse é um ponto importante na forma como eu concebo o sistema.

A memória não funciona assim:

coloco tudo o que sei de volta no prompt a cada conversa.

Ela funciona mais assim:

tenho uma memória externa onde posso ir buscar a informação pertinente no momento em que ela se torna útil.

O Contexto vira uma memória externa endereçável.

O detalhe que fazia perder um tempo enorme

Numa primeira versão, eu ainda não tinha otimizado a resolução dos identificadores do Google.

Toda vez que o ChatGPT queria ler ou escrever num Contexto, ele tinha que procurar o Spreadsheet correspondente e depois reencontrar o ID dele.

E na operação seguinte, recomeçava tudo.

Funcionava, mas algumas operações chegavam perto dos cinquenta segundos.

Boa parte do tempo era gasta simplesmente para reencontrar algo que já tinha sido encontrado poucos segundos antes.

Então acrescentei uma regra bem simples.

Uma vez aberto o Contexto, o ChatGPT guarda durante a conversa:

nome do Contexto
→ Spreadsheet
→ Spreadsheet ID

Todas as operações seguintes usam esse ID diretamente.

Ele só é resolvido de novo se:

• mudamos de Contexto;
• o ID não está mais disponível;
• o acesso falha.

Parece bem óbvio.

Mas muda enormemente a fluidez do sistema.

Persistir não é aprender

O motor em si expõe, no fim, pouquíssimos comandos.

Abra <contexto>
Persiste <conteúdo>
Tarefa <ação>
Ingere
Salve

Abra carrega um Contexto.

Persiste guarda uma nova fonte.

Tarefa acrescenta uma ação a realizar.

Ingere analisa as novas fontes e atualiza o conhecimento estruturado (criação ou enriquecimento de notas).

Salve atualiza os elementos que permitem retomar corretamente a missão numa próxima conversa.

Mas a distinção mais importante do sistema é provavelmente esta:

Persiste não é Ingere.

Quando digo:

Persiste ...

não estou pedindo ao motor que considere verdadeiro aquilo que acabei de dizer.

Estou pedindo apenas:

guarde este material.

Ele vira uma fonte.

Na ingestão, o motor pode então determinar que o que ela contém corresponde a:

• uma decisão de fato tomada;
• uma tarefa;
• uma contradição;
• uma informação útil para o estado atual;
• um conhecimento suficientemente estabilizado para virar uma nota atômica;
• ou simplesmente algo que deve ser guardado como fonte, sem ir além.

Isso evita um desvio que me parece especialmente perigoso nos sistemas de memória para IA.

Se toda produção da IA vira automaticamente um conhecimento do sistema, a IA acaba podendo usar as próprias produções anteriores como prova.

Então tento manter uma separação estrita:

fonte ≠ conhecimento ≠ estado ≠ síntese ≠ entregável

Uma fonte diz:

foi isto que foi dito ou observado.

Um conhecimento estabilizado diz outra coisa:

é isto que o sistema considera, de agora em diante, suficientemente estabelecido e reutilizável.

Um Contexto no bolso

É no celular que essa migração fica realmente interessante para mim.

Já trabalho muitíssimo com ditado de voz.

E neste caso específico, isso muda completamente a relação com o sistema.

Vamos retomar o exemplo de uma feira profissional.

Chego com um Contexto já preparado.

Do meu celular:

Abra Feira-X

Converso com um primeiro expositor.

Ao sair do estande, não tenho necessariamente vontade de parar, abrir um aplicativo de notas e digitar cinco minutos num tecladinho.

Caminho até o estande seguinte e simplesmente dito para o ChatGPT o que acabei de aprender.

Depois:

Persiste <o que acabei de ditar>

Isso pode levar algumas dezenas de segundos.

Sigo com o meu dia.

Depois de várias conversas:

Ingere

O motor começa então a estruturar o que coletei.

E é aí que o uso fica mais interessante do que um simples sistema de anotação.

Posso perguntar ao ChatGPT:

O que ainda me falta para entender de verdade este assunto?

Ou:

Quais contradições eu deveria verificar com o próximo expositor?

Ou ainda:

Quais perguntas importantes eu ainda não fiz a ninguém?

Consigo essa resposta enquanto ainda estou na feira.

E então posso ir fazer imediatamente as perguntas que faltam.

O ciclo fica assim:

conversa
   ↓
ditado de voz enquanto caminho
   ↓
Persiste
   ↓
Ingere
   ↓
procurar os pontos cegos
   ↓
voltar e fazer perguntas
   ↓
completar o Contexto

É provavelmente isso que mais muda no meu uso.

A IA não entra mais só depois da coleta, para me ajudar a produzir alguma coisa.

Ela pode entrar durante a coleta, quando ainda dá para melhorar a qualidade da informação.

Plaud: fazer as conversas entrarem no Contexto

Também uso um Plaud Note Pro.

Meu Plaud Note Pro, que posso usar para gravar conversas e entrevistas em campo.

O Plaud Note Pro é um pequeno gravador de voz que dá para usar para gravar reuniões, conversas ou entrevistas.

A gravação depois fica disponível no Plaud e pode ser transcrita.

Para o meu sistema, no entanto, não é o resumo automático produzido pelo Plaud que mais me interessa.

Quero recuperar a transcrição completa.

E há outra peça importante: o ChatGPT consegue acessar o Plaud diretamente pelo conector dele.

Do ChatGPT, posso então pedir, por exemplo:

Liste minhas três últimas gravações do Plaud e me diga em uma linha sobre o que fala cada uma.

Exemplo de consulta ao Plaud a partir do ChatGPT para reencontrar as últimas gravações.

O ChatGPT consegue reencontrar essas gravações e depois recuperar diretamente a transcrição delas.

Isso permite imaginar um workflow bem mais direto:

conversa real
        ↓
Plaud
        ↓
transcrição
        ↓
ChatGPT recupera diretamente a transcrição
        ↓
Persiste
        ↓
fonte bruta do Contexto
        ↓
Ingere

Não preciso, portanto:

• baixar manualmente um arquivo;
• abrir a transcrição;
• copiá-la;
• voltar ao ChatGPT;
• colá-la.

Posso fazer tudo isso automaticamente, por voz, a partir do celular.

E prefiro fazer entrar no Contexto a transcrição bruta completa em vez de um simples resumo.

O resumo já é uma interpretação.

A transcrição continua bem mais perto do material de origem.

Uma vez que a conversa está no Contexto, posso perguntar:

• o que essa pessoa acabou de me ensinar de verdade?
• o que contradiz as conversas anteriores?
• quais afirmações merecem ser verificadas?
• quais perguntas eu deveria fazer para a próxima pessoa?

Os diferentes blocos necessários já funcionam.

Por outro lado, ainda não coloquei à prova de ponta a ponta esse workflow Plaud → ChatGPT → Contexto em longos dias de campo para dizer que ele está perfeitamente fluido.

Então ainda é um uso a testar mais.

Como reproduzir o sistema

Preparei dois arquivos que correspondem aos dois níveis de diretrizes do motor.

O CORE

O CORE está disponível aqui:

_directive

É esta parte que você deve copiar nas diretrizes do Projeto ChatGPT.

A diretriz estendida

A diretriz detalhada está disponível aqui:

_directive_etendue

Ela deve ser copiada num Google Doc ao qual o ChatGPT possa acessar.

Antes de começar, é preciso obviamente conectar o Google Drive ao ChatGPT e permitir que ele acesse os documentos usados pelo motor.

Configurar os IDs

O CORE contém, entre outras coisas, dois identificadores:

DOCUMENT_ID = xxxx
FOLDER_ID = xxxx

DOCUMENT_ID corresponde ao Google Doc que contém a diretriz estendida.

Numa URL como:

https://docs.google.com/document/d/xxxx/edit

a parte xxxx é o identificador do documento.

FOLDER_ID corresponde à pasta do Google Drive onde os Contextos serão armazenados.

Para uma URL como:

https://drive.google.com/drive/folders/xxxx

o identificador é de novo a parte xxxx.

Cada usuário deve, claro, substituir esses valores pelos do próprio ambiente.

Um Spreadsheet por Contexto

Quando um novo Contexto é criado, o motor cria um Spreadsheet contendo:

00-FRAME
01-STATE
03-SESSIONS
04-ATOMIC
05-OUTPUTS

Ele é então colocado na pasta definida por FOLDER_ID.

Não é necessário copiar manualmente o identificador de cada um desses Spreadsheets nas diretrizes.

Quando peço:

Abra Meu Contexto

o ChatGPT procura o Spreadsheet correspondente na pasta dos Contextos, recupera o ID dele e depois o guarda durante a conversa.

O sistema está então operacional.

O que essa gambiarra permite — e seus limites

Esta versão ChatGPT não substitui meu motor usado com o Codex ou o Claude Code.

Não era esse o objetivo.

Ela tem vários limites.

Ela é mais lenta.

Ela é menos adequada a Contextos que precisam diretamente de scripts Python, de chamadas de API ou de um ambiente de execução mais rico.

E, sobretudo, ainda me falta recuo sobre o comportamento dela quando um Contexto cresce de verdade ao longo de várias semanas.

Então eu a vejo como um modo autônomo complementar.

No meu Mac, o Codex ou o Claude Code continuam mais adequados a certas missões.

Mas do meu celular, agora posso usar um Contexto sem depender de o meu Mac estar ligado e acessível.

E era exatamente esse o problema que eu queria resolver.

Há também uma observação divertida ligada à cota do Codex.

Durante toda essa experimentação no ChatGPT, a cota do Codex exibida não diminuiu.

Consumo observado:

0

Obviamente não afirmo que isso constitua uma regra geral sobre a forma como a OpenAI cobra ou contabiliza esse tipo de uso.

Constato apenas que, durante essa experiência, essa gambiarra não consumiu minha cota do Codex.

O sistema já serviu para produzir este artigo

No começo, meu primeiro hack do Google Sheets respondia a uma pergunta bem limitada:

como tirar uma informação do ChatGPT e guardá-la de forma duradoura?

Alguns dias depois, a pergunta tinha virado:

e se eu tirasse toda a memória estruturada do Contexto?

É isso, no fim, que esse sistema faz.

O ChatGPT não precisa mais "lembrar de tudo".

Ele precisa sobretudo saber:

• onde procurar;
• o que carregar;
• o que persistir;
• como qualificar a informação;
• como reencontrar o que já foi aprendido;
• em que pé está o trabalho.

A fórmula continua bem simples:

O ChatGPT raciocina.
As diretrizes definem o motor.
O Google Sheets lembra.

E há algo bastante satisfatório no fato de que a preparação e a redação deste artigo serviram elas mesmas para testar o sistema que o artigo descreve.

Para preparar este texto, usei exclusivamente esse Contexto dentro do ChatGPT.

Persisti ali minhas ideias.

Depois as ingeri.

Identificamos pontos cegos.

Corrigi formulações.

Criamos e concluímos tarefas.

Acrescentei os elementos que faltavam.

Depois produzi uma primeira versão do artigo, reli e usei o mesmo Contexto para preparar esta V2.

Ou seja, o sistema não serviu apenas de demonstrador técnico.

Ele já foi usado para fazer de verdade o trabalho para o qual eu o construí.

A pergunta, portanto, não é mais bem essa:

isso funciona?

Funciona.

A pergunta que me interessa agora é outra:

essa arquitetura continuará igualmente prática quando o mesmo Contexto for posto à prova em campo, durante uma semana inteira de feiras profissionais?

É isso que a continuação do uso vai permitir verificar.