Criando uma Memória Persistente para o Jarvis com Python + JSON

🌌 Projeto CodeVerse Python – #39/2025

👋 Fala, galera dev!

🚀 Já estamos ao artigo 39 do Projeto CodeVersePython2025, e hoje quero compartilhar uma ideia que comecei a testar: dar ao nosso J.A.R.V.I.S. uma memória de longo prazo. Isso significa que ele poderá guardar informações e lembrar delas em execuções futuras, ficando ainda mais próximo de um verdadeiro assistente pessoal.

Mas vale lembrar que essa ainda não é a solução definitiva. Estou experimentando diferentes formas de implementar essa memória e avaliando qual é a mais eficaz. Entre as possibilidades, penso também em usar técnicas de RAG (Retrieval Augmented Generation) combinadas com embeddings, mas esse é um assunto mais avançado que vou trazer em um artigo futuro, depois de estudar com calma.

Afinal, ninguém nasce sabendo de tudo, e a correria do dia a dia muitas vezes não nos deixa mergulhar de cabeça em cada detalhe. Mas o importante é dar passos consistentes. E hoje vamos ver como já é possível implementar uma memória inicial e prática para o nosso Jarvis.

Se você parar para pensar, os grandes assistentes virtuais (como Alexa, Siri e o próprio Jarvis do Tony Stark) não só escutam e respondem, mas também lembram do que foi dito antes. É isso que dá continuidade a uma conversa e faz o assistente parecer inteligente de verdade.

No nosso caso, vamos ensinar o Jarvis a guardar informações importantes em arquivos e depois usá-las sempre que for necessário. Assim ele pode lembrar, por exemplo, sua cor favorita, o nome do seu time, ou até anotações rápidas que você pedir.

E o melhor? Vamos fazer isso apenas com recursos simples do Python, sem precisar de banco de dados complexo.

🧠 Como funciona a memória do Jarvis?

A ideia é bem simples: Quando você der um comando como:

👉 “Jarvis, lembre-se que minha cor favorita é azul”
Ele vai salvar essa informação em um arquivo .txt ou .json.

Depois, se você perguntar:

👉 “Jarvis, qual é minha cor favorita?”
Ele vai ler o arquivo, encontrar a informação e responder:
👉 “Senhor Carlos, sua cor favorita é azul.”

Ou seja, a memória é basicamente salvar e carregar dados sempre que pedirmos.

🐍 Criando a memória em Python

Antes de integrar ao Jarvis, vamos entender o conceito de forma separada e bem simples: como criar um sistema de armazenamento em memória de longo prazo. Nesse caso, vamos salvar as informações em um arquivo (pode ser no formato .json ou .txt) no modelo chave → valor.

Funciona assim: quando pedimos para o Jarvis lembrar de algo, ele guarda essa informação associada a uma chave (por exemplo: “cor favorita” → “azul”). Depois, quando perguntamos de novo, ele procura se existe essa chave registrada no arquivo e retorna o valor correspondente. Se encontrar, ele responde com o que lembrava; caso contrário, diz que não encontrou nada.

import json

# Arquivo onde o Jarvis vai guardar as informações
arquivo_memoria = "memoria_jarvis.json"

# Função para salvar informações
def salvar_memoria(chave, valor):
  try:
      with open(arquivo_memoria, "r") as f:
          memoria = json.load(f)
  except FileNotFoundError:
      memoria = {}

  memoria[chave] = valor

  with open(arquivo_memoria, "w") as f:
      json.dump(memoria, f)

# Função para recuperar informações
def lembrar(chave):
  try:
      with open(arquivo_memoria, "r") as f:
          memoria = json.load(f)
      return memoria.get(chave, "Não encontrei nada sobre isso, senhor.")
  except FileNotFoundError:
      return "Ainda não tenho nada salvo, senhor."

# Exemplo prático
salvar_memoria("cor favorita", "azul")
print(lembrar("cor favorita"))

Mas calma, sei que esse código tem um monte de conceitos de manipulação de arquivos que ainda não foi visto durante nossa trajetória, e por isso vamos esmiussar todo esse código logo a seguir para entendermos como cada parte deste código funciona. Para que possamos adicionar ao nosso código J.A.R.V.I.S. e darmos manutenções futuras em nosso código!

Bibliotecas e arquivo de memória

Antes de começarmos devemos importar a biblioteca json, que já vem com o Python (não precisa instalar). Ela transforma dados do Python (como dicionários) em texto no formato JSON e vice-versa. JSON é um formato super comum pra guardar informações de forma simples (chave → valor), fácil de ler e de compartilhar.

import json

Logo depois criamos a variável arquivo_memoria e guardamos dentro dela o arquivo marmoria_jarvis.json que será o lugar onde vamos salvar as lembranças do Jarvis. Se esse arquivo não existir, o código cria na primeira gravação. Ele fica na mesma pasta do script.

# Arquivo onde o Jarvis vai guardar as informações
arquivo_memoria = "memoria_jarvis.json"

Salvando informações (escrever na “memória”)

Definimos uma função chamada salvar_memoria que recebe dois textos: uma chave (ex.: "cor favorita") e um valor (ex.: "azul") como por exemplo.

def salvar_memoria(chave, valor):

Nessa parte do código utilizamos o try para abrir o arquivo de memória no modo leitura ("r").
with open(...) as f: abre o arquivo e fecha sozinho no final (mesmo se der erro).
json.load(f): lê o conteúdo do arquivo (que está em JSON) e transforma em um dicionário Python chamado memoria.

 try:
      with open(arquivo_memoria, "r") as f:
          memoria = json.load(f)

Se o arquivo ainda não existe, cairá aqui. A gente começa com um dicionário vazio ({}), como uma memória “em branco”. Essa parte funciona junto do try, onde o try, tenta e caso não consiga ou dê algum erro, ele entra no except, criando assim o arquivo de memória em branco.

 except FileNotFoundError:
      memoria = {}

Este trecho do código adiciona/atualiza no dicionário a chave com o valor informado. Ex.: memoria["cor favorita"] = "azul".

 memoria[chave] = valor

Aqui abrimos o arquivo no modo escrita ("w") — isso sobrescreve o conteúdo anterior com a versão atualizada da memória.
json.dump(memoria, f): grava o dicionário memoria dentro do arquivo, em formato JSON.

with open(arquivo_memoria, "w") as f: json.dump(memoria, f)

Lembrar informações (ler da “memória”)

def lembrar(chave):

O que é isso? Define uma função que recebe uma chave e devolve o valor guardado (se tiver).

 try:
      with open(arquivo_memoria, "r") as f:
          memoria = json.load(f)
      return memoria.get(chave, "Não encontrei nada sobre isso, senhor.")

O que é isso? Abre o arquivo, carrega o conteúdo como dicionário (memoria) e procura a chave pedida.
memoria.get(chave, "mensagem"): se a chave existir, retorna o valor; se não existir, retorna a mensagem padrão: "Não encontrei nada sobre isso, senhor."

 except FileNotFoundError:
      return "Ainda não tenho nada salvo, senhor."

Por que isso? Se o arquivo não existe, quer dizer que ainda não salvamos nada. Então devolvemos essa mensagem educada.

Resumo da função: Abre o arquivo, lê o que tem, e devolve o valor da chave; se não achar (ou se o arquivo nem existir), dá um retorno amigável.

Esse arquivo de memória chamado memoria_jarvis.json fica guardado na mesma pasta onde está o seu script Python. Isso significa que não tem mistério: sempre que você rodar o programa, ele vai procurar esse arquivo ao lado do código principal.

E o melhor é que esse arquivo pode ser aberto e lido fora do Python sem problema algum. Como ele está no formato JSON, o conteúdo é texto puro e fácil de entender, organizado em pares de chave e valor, como “cor favorita: azul”. É quase como abrir um bloquinho de anotações digital onde o Jarvis escreve tudo o que você pede para lembrar.

Agora, se em algum momento você quiser apagar a memória do Jarvis, também é simples. Basta deletar o arquivo memoria_jarvis.json da pasta, e ele começará novamente do zero na próxima vez que o programa for executado. Outra opção é editar o arquivo manualmente e remover apenas a informação que não quer mais guardar. Assim você mantém o controle total sobre o que o Jarvis deve ou não se lembrar.

🤖 Integrando ao Jarvis

Agora vamos juntar isso ao nosso projeto. O Jarvis vai ouvir frases como “lembrar que…” e salvar no arquivo. Depois, quando pedirmos “o que você lembra sobre…”, ele vai buscar a informação e responder com sua voz.

import speech_recognition as sr
import pyttsx3
import json

engine = pyttsx3.init()
r = sr.Recognizer()
arquivo_memoria = "memoria_jarvis.json"

def falar(texto):
  engine.say(texto)
  engine.runAndWait()

def salvar_memoria(chave, valor):
  try:
      with open(arquivo_memoria, "r") as f:
          memoria = json.load(f)
  except FileNotFoundError:
      memoria = {}

  memoria[chave] = valor

  with open(arquivo_memoria, "w") as f:
      json.dump(memoria, f)

def lembrar(chave):
  try:
      with open(arquivo_memoria, "r") as f:
          memoria = json.load(f)
      return memoria.get(chave, "Não encontrei nada sobre isso, senhor.")
  except FileNotFoundError:
      return "Ainda não tenho nada salvo, senhor."

with sr.Microphone() as source:
  falar("Estou ouvindo, senhor. O que deseja salvar ou perguntar?")
  audio = r.listen(source)

try:
  comando = r.recognize_google(audio, language="pt-BR").lower()

  if "lembrar que" in comando:
      dado = comando.replace("lembrar que", "").strip()
      chave, valor = dado.split(" é ")
      salvar_memoria(chave.strip(), valor.strip())
      falar(f"Entendido, senhor. Vou me lembrar que {chave} é {valor}.")

  elif "o que você lembra sobre" in comando:
      chave = comando.replace("o que você lembra sobre", "").strip()
      info = lembrar(chave)
      falar(info)

except:
  falar("Não consegui entender, senhor.")

👉 Exemplo de uso:

Você diz: “Jarvis, lembrar que meu time é o Flamengo”
Depois pergunta: “Jarvis, o que você lembra sobre meu time?”
Ele responde: “Seu time é o Flamengo, senhor.”

🔮 Concluindo...

Hoje demos um passo gigantesco para transformar o nosso Jarvis em um verdadeiro assistente pessoal inteligente.

✅ Vimos como implementar uma memória simples com Python usando arquivos .json.
✅ Fizemos o Jarvis guardar informações que você pede.
✅ Fizemos ele recuperar e responder essas informações, mesmo depois de reiniciar.

Agora o Jarvis não é apenas um ouvinte e executor de comandos. Ele pode lembrar de você, das suas preferências e do que foi dito antes. Isso aproxima muito mais nosso projeto de um assistente real, como Alexa, Siri e, claro, o próprio Jarvis do Tony Stark.

Nos próximos artigos, vamos expandir essa memória para que ela seja integrada à IA do Google Gemini, permitindo que o Jarvis use essas informações em diálogos mais inteligentes e naturais. Até porque ele está evoluindo, mais suas respostas ainda estão muito amarradas para serem respondidas apenas quando forem ditas perguntas exatamente da forma como foram salvas em memória, sem analisar o contexto para responder as nossas perguntas.

👉 Curtiu esse artigo? Então me siga no GitHub e no LinkedIn para acompanhar cada passo do Projeto CodeVersePython2025 e aprender a construir o seu próprio Jarvis.

Porque o futuro não é esperar a tecnologia chegar. É a gente criar ele hoje. ⚡