🧠Jarvis com Memória Contextual: lembrando do que foi dito na conversa

🌌Projeto CodeVerse Python – #43/2025

👋 Fala, galera dev! 🚀

Chegamos ao artigo #43 da nossa jornada CodeVersePython2025, e hoje vamos dar mais um passo rumo a um JARVIS ainda mais inteligente e cada vez mais parecido com o original do Tony Stark.

Nos últimos capítulos, nosso assistente já aprendeu a ouvir, falar, salvar informações e até guardar memórias permanentes em arquivos JSON. Mas agora… é hora de dar um passo a mais na inteligência do Jarvis: ensinar ele a lembrar do que foi dito durante a conversa.

Sim, hoje vamos criar a memória contextual, ou seja uma mini “RAM” que permite o assistente manter o contexto, lembrar de falas recentes e responder de forma mais natural, igual nós humanos fazemos, ao se lembrar do que foi dito durante uma conversa, assim o jarvis fará, ele se lembrará das utlimas coisas conversadas.

🦸♂️ Uma comparação rápida com o Jarvis dos filmes

Vamos então fazer uma comparação bem simples, que vai nos ajudara a contextualizar para que serviria a memória tempoerária do JARVIS, imagine o Tony Stark trabalhando no laboratório. Ele diz:

“Jarvis, me mostre o novo protótipo da Mark 50.”

E logo em seguida:

“Troque o material da perna por titânio.”

O Jarvis entende automaticamente que o assunto ainda é a Mark 50. Ele não precisa que o Stark repita tudo de novo, citandos sobre o mark 50 e depois fazer seu pedido.

🧩 Essa é a diferença entre um simples “comando de voz” e uma conversa inteligente. E é exatamente isso que vamos implementar aqui.

🧩 O que é uma memória contextual?

Pense na memória contextual como a memória de curto prazo do Jarvis. Ela guarda as últimas informações que foram ditas como o nome do usuário, o último comando ou o tema da conversa, mas sem salvar nada em disco.

Ou seja:

• 💾 Não é uma memória permanente (como a do artigo #39 com JSON).
• ⚙️ Funciona apenas durante a execução do programa.
• 🧠 É o que permite o Jarvis dizer coisas como “Sim, lembro disso, senhor.”

🐍 Código: Criando a mini memória de curto prazo

Aqui está o exemplo prático que traz essa inteligência contextual ao nosso assistente, aplicando de forma prática no código:

import speech_recognition as sr
import pyttsx3
import random

engine = pyttsx3.init()
r = sr.Recognizer()

# Lista que servirá como "memória RAM" do Jarvis
memoria_contextual = []

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

def lembrar_contexto():
  if memoria_contextual:
      return memoria_contextual[-1]
  else:
      return None

def adicionar_contexto(info):
  memoria_contextual.append(info)
  if len(memoria_contextual) > 5:  # Mantém só as 5 últimas falas
      memoria_contextual.pop(0)

with sr.Microphone() as source:
  falar("Olá, senhor. Em que posso ajudar hoje?")
  audio = r.listen(source)

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

  if "meu nome é" in comando:
      nome = comando.replace("meu nome é", "").strip()
      adicionar_contexto({"tipo": "nome", "valor": nome})
      falar(f"Prazer, {nome}. Vou me lembrar disso durante nossa conversa.")

  elif "qual é o meu nome" in comando:
      ultimo = lembrar_contexto()
      if ultimo and ultimo["tipo"] == "nome":
          falar(f"Seu nome é {ultimo['valor']}, senhor.")
      else:
          falar("Desculpe, ainda não sei o seu nome.")

  elif "como eu disse antes" in comando:
      ultimo = lembrar_contexto()
      if ultimo:
          falar(f"Você mencionou {ultimo['valor']} anteriormente, senhor.")
      else:
          falar("Desculpe, não lembro de nada anterior ainda.")

  else:
      adicionar_contexto({"tipo": "outro", "valor": comando})
      falar("Entendido, senhor. Informação registrada.")

except:
  falar("Desculpe, não consegui entender.")

🧠 Entendendo o código (de forma simples)

Tudo começa com a variável memoria_contextual, que é como um bloco de notas temporário. Ela guarda o que o Jarvis ouviu, mas apenas durante a execução, se você fechar o programa, tudo é apagado.

Depois, a função adicionar_contexto(info) adiciona novas informações e mantém só as últimas 5, simulando o comportamento da memória humana: lembrar o que foi dito há pouco, mas esquecer o que já passou.

A função lembrar_contexto() devolve o último item guardado, permitindo que o Jarvis diga coisas como “Você mencionou isso há pouco, senhor.”

E o que acontece quando você fala?

• Se disser “meu nome é Carlos”, o Jarvis guarda seu nome temporariamente.
• Se logo depois perguntar “qual é o meu nome?”, ele responde corretamente.
• Se perguntar “como eu disse antes?”, ele recorda o último item da memória.

É uma lógica simples, mas poderosa, o primeiro passo para dar consciência de contexto ao nosso assistente.

🔍 Memória Contextual x Memória Persistente

👉 Memória Contextual: Existe apenas durante a execução. Serve para manter o contexto da conversa. Exemplo:

“Jarvis, meu nome é Carlos.” “Qual é o meu nome?” → “Seu nome é Carlos.”

👉 Memória Persistente (artigo #39): Grava em disco (JSON). Continua existindo mesmo depois que o Jarvis é fechado. Exemplo:

“Jarvis, lembre que meu time é o Flamengo.” (Fecha o programa e abre de novo) “Jarvis, qual é o meu time?” → “Seu time é o Flamengo, senhor.”

Essa combinação — contexto temporário + memória permanente — é o que forma a base de sistemas inteligentes modernos como Alexa, Siri e ChatGPT.

💬 Tornando o diálogo mais humano

Quer deixar o Jarvis mais natural? Basta adicionar variações de respostas aleatórias, desta forma as respostas dele as suas perguntas se tornam mais naturais e menos mecânicas, afinal nossa conversa não é igual as aulas de ingles onde os prefessores perguntavam "what is your name" e respondíamos "my name is Carlos", usamos respostas diferentes, respondendo a mesma pergunta, assim aplicamos o código abaixo para dar essa versatilidade de respostas:

respostas = [
  "Claro, senhor. Você já havia me dito isso.",
  "Sim, lembro perfeitamente.",
  "Exato, como o senhor mencionou há pouco."
]
falar(random.choice(respostas)) 

Agora ele deixa de parecer um robô repetitivo e passa a soar mais espontâneo, como o verdadeiro JARVIS.

🔮 Concluindo...

Hoje demos um passo importante rumo a um Jarvis com raciocínio próprio. Aprendemos a criar uma mini-RAM de conversa, capaz de lembrar o que foi dito há pouco tempo e responder com base nisso.

• ✅ Criamos uma memória contextual com listas.
• ✅ Aprendemos a registrar e recuperar contexto recente.
• ✅ Entendemos a diferença entre memória temporária e persistente.

E o mais importante: demos o primeiro passo para um assistente que pensa antes de responder. Nos próximos artigos, vamos estar finalizando nosso projeto jarvis e integrando tudo o que vimos e aplicamos durante todo o ano de 2025. Nas proximas quatro semanas do mes de novembro, vamos juntar todas as peças do quebra cabeça e formar nosso projeto completo.

No mes de dezembro, vamos aprender a publicar nosso projeto no youtube, fazer gravações dele em execução e edições de video. Pois não adianta nada criarmos um suer projeto, se não sabemos divulga-lo da forma correta.

✨ Porque, no final das contas, o Jarvis não é só código. Ele é um reflexo de como a inteligência artificial pode se adaptar à gente — e não o contrário.

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

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