Olá, agente em formação! Emma aqui, de volta ao agent101.net, e hoje, vamos nos aprofundar em algo que está na minha cabeça (e no meu ambiente de desenvolvimento) há semanas: como fazer com que seu agente IA realmente se lembre das coisas. Não apenas lembrar para uma tarefa, mas manter esse contexto, esses aprendizados, essa personalidade ao longo de várias interações. Porque, para ser bem sincera, um agente distraído não é nada mais do que um script sofisticado, não é mesmo?
A data atual é 25 de março de 2026, e o mundo dos agentes IA está evoluindo a uma velocidade incrível. Há um ou dois anos, ficávamos impressionados com um chatbot capaz de manter uma conversa decente por cinco minutos. Agora? Esperamos que nossos agentes sejam nossos companheiros digitais, nossos assistentes de pesquisa, nossos revisores de código, e eles devem dar a impressão de nos conhecer, ou pelo menos saber o que estão fazendo. Não se trata de criar uma AGI perfeitamente desenvolvida (ainda não!), mas de tornar seus agentes IA cotidianos e práticos mais úteis, mais inteligentes e menos como Dory em Procurando Nemo.
Eu experimentei diversos frameworks de agentes, de LangChain a AutoGen, e um obstáculo constante para iniciantes (e, honestamente, para mim às vezes!) é a gestão de estado e memória de maneira eficaz. Isso é frequentemente negligenciado nos tutoriais básicos, que tendem a se concentrar em um simples loop de prompt-resposta. Mas se você quer que seu agente se baseie em suas ações anteriores, aprenda com seus erros, ou até mesmo se lembre do seu nome após a primeira interação, você precisa de uma estratégia.
Por que meu agente continua esquecendo do que conversamos?
Imagine isto: eu estava tentando criar um agente simples para me ajudar a brainstormar ideias para posts de blog. Minha instalação inicial era bastante básica: eu lhe dava um assunto, e ele me dava ideias. Ótimo para prompts pontuais. Mas então, eu dizia: “Certo, agora desenvolva a ideia número três,” e ele me olhava (no sentido figurado) com um olhar vazio, perguntando: “Que ideia número três?” Era frustrante! Isso significava que eu tinha que constantemente relembrar o contexto, tornando a interação estranha e ineficaz.
Essa “distração” vem da natureza sem estado da maioria dos grandes modelos de linguagem (LLMs) em sua essência. Cada chamada de API muitas vezes é tratada como uma nova solicitação. Ele não se lembra intrinsecamente do histórico das conversas ou dos resultados de chamadas anteriores. Os frameworks de agentes existem para orquestrar essas chamadas, mas você, o desenvolvedor, é responsável por decidir quais informações manter. É aí que entra a memória.
As duas grandes categorias de memória dos agentes: memória de curto prazo e memória de longo prazo
Quando falamos de um agente IA “lembrando”, geralmente estamos nos referindo a dois tipos principais de memória, de forma semelhante à nossa própria memória:
Memória de curto prazo: O buffer de conversa
Este é o tipo de memória mais simples e com o qual a maioria dos iniciantes deve começar. A memória de curto prazo se refere a lembrar do passado imediato – da conversa atual. Pense nela como sua memória de trabalho quando você conversa com um amigo. Você se lembra do que foi dito recentemente, de quem disse o quê, e do fio geral da discussão.
Para um agente IA, isso geralmente significa armazenar a troca recente de mensagens (prompts e respostas) e enviá-las com cada novo prompt ao LLM. A maioria dos frameworks de agentes oferece maneiras simples de implementar isso.
Exemplo prático: ConversationBufferMemory do LangChain
Vamos ver um exemplo básico em Python utilizando LangChain. Isso demonstra como manter um histórico simples de conversa.
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
# Inicializar seu LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
# Inicializar a memória
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# Definir um modelo de prompt simples
template = """Você é um assistente IA amigável.
Conversa atual:
{chat_history}
Humano: {input}
IA:"""
prompt = PromptTemplate(input_variables=["chat_history", "input"], template=template)
# Criar a cadeia de conversa
conversation_chain = LLMChain(
llm=llm,
prompt=prompt,
verbose=True, # Permite ver o que está acontecendo
memory=memory
)
# Primeira interação
print("--- Interação 1 ---")
response1 = conversation_chain.invoke({"input": "Oi, me chamo Emma. E você?" })
print(f"IA: {response1['text']}")
# Segunda interação, note como 'chat_history' é passado automaticamente
print("\n--- Interação 2 ---")
response2 = conversation_chain.invoke({"input": "Pode me contar um fato divertido sobre IA?" })
print(f"IA: {response2['text']}")
# Terceira interação, o agente se lembra do meu nome!
print("\n--- Interação 3 ---")
response3 = conversation_chain.invoke({"input": "Obrigada! A propósito, quantos anos tem a Emma?" })
print(f"IA: {response3['text']}")
print("\n--- Estado final da memória ---")
print(memory.load_memory_variables({}))
O que está acontecendo aqui?
- `ConversationBufferMemory` armazena as mensagens à medida que são enviadas.
- O `PromptTemplate` inclui uma variável `{chat_history}`.
- Quando `conversation_chain.invoke()` é chamado, o LangChain injeta automaticamente o histórico de conversa armazenado no prompt antes de enviá-lo ao LLM.
Isso é ótimo para conversas curtas. Mas o que acontece se sua conversa se estender? Os LLMs têm janelas de contexto (um limite na quantidade de texto que podem processar de uma vez). Se seu histórico de chat ficar muito longo, você atingirá um desses limites e receberá um erro, ou as partes mais antigas da conversa serão truncadas. É aí que estratégias de memória de curto prazo mais avançadas entram em cena, como `ConversationBufferWindowMemory` (lembra-se apenas das N interações mais recentes) ou `ConversationSummaryBufferMemory` (resume as partes mais antigas da conversa para economizar espaço).
Memória de longo prazo: Base de conhecimento e armazenamento de vetores
A memória de curto prazo diz respeito ao chat imediato. A memória de longo prazo diz respeito ao conhecimento persistente, fatos, experiências passadas, ou até mesmo uma “personalidade” aprendida que um agente deve manter ao longo das sessões ou até mesmo através de diferentes tarefas. É aí que as coisas se tornam realmente interessantes e poderosas.
Meu exemplo de agente de brainstorming para posts de blog é um caso perfeito para a memória de longo prazo. Quero que ele se lembre do meu estilo favorito, da minha nicho (agentes IA para iniciantes), e até mesmo de tópicos passados que funcionaram bem, para que ele não sugira algo totalmente fora do assunto a cada vez. Não quero explicar agent101.net todos os dias!
A forma mais comum de implementar a memória de longo prazo envolve atualmente dois componentes-chave:
- Modelos de inserção: Esses modelos convertem texto (seu conhecimento, suas interações passadas, etc.) em vetores numéricos. Textos com significados semelhantes terão vetores que são “próximos” uns dos outros numericamente.
- Armazenamentos de vetores (ou bancos de dados de vetores): Essas são bases de dados especializadas projetadas para armazenar e pesquisar esses vetores numéricos de forma eficiente. Quando você tem uma nova solicitação ou um novo contexto, você o converte em um vetor, e então pesquisa no armazenamento de vetores os vetores existentes mais semelhantes. O texto associado a esses vetores semelhantes é então recuperado e pode ser injetado no seu prompt.
Esse processo é frequentemente chamado de geração aumentada por recuperação (RAG). Você recupera informações relevantes da sua memória de longo prazo e aumenta o prompt do LLM.
Exemplo prático: Usando um armazenamento de vetores para a personalidade do agente
Imaginemos que queremos que nosso agente tenha uma “persona” coerente ou acesse uma base de conhecimento sobre nossa marca. Podemos armazenar essa informação em um armazenamento de vetores.
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.prompts import PromptTemplate
# 1. Definir nosso 'conhecimento a longo prazo' (por exemplo, persona do agente, diretrizes da marca)
# Em um cenário real, isso seria carregado de um arquivo, banco de dados, etc.
brand_persona_info = """
O nome do agente é Emma. Ela escreve para agent101.net.
Seu estilo de escrita é amigável, prático, e se concentra em ajudar iniciantes a entender os agentes de IA.
Ela utiliza anedotas e evita jargões técnicos excessivos sempre que possível.
Seu público principal é composto por indivíduos que estão se familiarizando com agentes de IA ou em busca de conselhos práticos de implementação.
Os temas principais incluem: LangChain, AutoGen, engenharia de prompts para agentes, gerenciamento de memória, uso de ferramentas.
Ela tem como objetivo desmistificar conceitos complexos de IA.
"""
# 2. Dividir o texto em partes gerenciáveis (para documentos maiores)
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
docs = text_splitter.create_documents([brand_persona_info])
# 3. Criar embeddings e armazená-los em um repositório vetorial
# FAISS é uma boa opção local para iniciantes. Para produção, você usaria Pinecone, Chroma, etc.
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)
# 4. Inicializar o LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)
# 5. Criar um recuperador a partir do repositório vetorial
retriever = vectorstore.as_retriever()
# 6. Definir um modelo de prompt personalizado para a cadeia RAG
# Dizemos explicitamente ao LLM para usar o contexto fornecido.
custom_prompt_template = """Use o seguinte contexto para responder à pergunta do usuário.
Se você não souber a resposta baseada no contexto, diga simplesmente que não sabe, não tente inventar uma resposta.
Contexto:
{context}
Pergunta: {question}
"""
custom_prompt = PromptTemplate(
template=custom_prompt_template,
input_variables=["context", "question"]
)
# 7. Criar a cadeia RAG
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff", # 'stuff' significa colocar todos os documentos recuperados no prompt
retriever=retriever,
return_source_documents=True,
chain_type_kwargs={"prompt": custom_prompt}
)
# Agora, vamos interrogar o agente
print("--- Consulta 1 ---")
query1 = "Quem é você e sobre o que você escreve?"
result1 = qa_chain.invoke({"query": query1})
print(f"IA: {result1['result']}")
print("\n--- Consulta 2 ---")
query2 = "Qual é o estilo de escrita preferido da Emma?"
result2 = qa_chain.invoke({"query": query2})
print(f"IA: {result2['result']}")
print("\n--- Consulta 3 (Conhecimento Externo) ---")
query3 = "Qual é a capital da França?" # Essa informação não está na nossa informação de persona
result3 = qa_chain.invoke({"query": query3})
print(f"IA: {result3['result']}") # Ela ainda deve responder, pois o LLM tem conhecimentos gerais,
# mas se quiséssemos estritamente *somente* o contexto, ajustaríamos o prompt.
# Nota importante: Se você deseja que o agente respeite estritamente *somente* o contexto fornecido
# e se recuse a responder se o contexto não contiver a resposta, você deve ser muito
# explícito em seu custom_prompt_template. Por exemplo: "Baseado SOMENTE no contexto a seguir..."
Análise do exemplo RAG:
- Pegamos nosso texto de “persona”.
- Dividimos em partes (importante para documentos maiores).
- Utilizamos `OpenAIEmbeddings` para transformar essas partes em vetores numéricos.
- `FAISS` (um repositório vetorial local) armazenou esses vetores.
- Quando fizemos uma pergunta, o `retriever` pesquisou em `FAISS` as partes de texto mais relevantes.
- Essas partes relevantes foram então inseridas em nosso `custom_prompt_template` como `{context}`.
- Por fim, o LLM utilizou esse prompt aprimorado para responder à pergunta, dando a impressão de que ele “lembrava” de sua persona.
Essa abordagem é incrivelmente flexível. Você pode usá-la para :
- Armazenar documentos (PDF, artigos, wikis internos).
- Lembrar as preferências dos usuários ao longo do tempo.
- Manter a “personalidade” de um agente ou instruções específicas.
- Armazenar ações de agentes bem-sucedidas anteriores ou estratégias de planejamento.
Minha opinião pessoal sobre como iniciar com a memória
Quando comecei, tentei construir tudo do zero, achando que era inteligente. Aprendi rapidamente que usar estruturas estabelecidas como LangChain ou AutoGen (que têm seus próprios conceitos de memória, frequentemente através do histórico de mensagens do agente) é a melhor solução. Elas gerenciam muito do código repetitivo para você.
Meu conselho para iniciantes:
- Comece com `ConversationBufferMemory`. É o mais simples e tornará imediatamente seus agentes mais conversacionais.
- Compreenda os limites da janela de contexto. Se suas conversas se tornarem longas, passe para `ConversationBufferWindowMemory` ou `ConversationSummaryBufferMemory` para evitar a truncagem ou custos excessivos de API.
- Não se jogue direto em sistemas RAG complexos. Familiarize-se primeiro com a memória de bate-papo básica. Uma vez que você veja a necessidade de um conhecimento persistente ou recordação de fatos específicos, explore os repositórios vetoriais.
- Preste atenção na engenharia de prompts para o RAG. A forma como você pede ao LLM para usar o contexto recuperado é crucial. Experimente frases como “Use SOMENTE o contexto a seguir,” ou “Complete seus conhecimentos com o contexto a seguir.”
- Separe as necessidades de curto e longo prazo. Não tente reunir toda a história de vida do seu agente no `chat_history`. Reserve `chat_history` para a interação atual e use o RAG para todo o resto.
Um desafio que enfrentei foi lidar com a memória através de várias *sessões*. Se meu agente reiniciasse, sua `ConversationBufferMemory` era perdida. Para uma memória de curto prazo verdadeiramente persistente (por exemplo, se você deseja retomar uma conversa de onde parou ontem), você precisará serializar e armazenar seu objeto `memory` (por exemplo, sob a forma de um arquivo JSON ou em um banco de dados) e carregá-lo quando o agente iniciar. Isso adiciona uma camada adicional de complexidade, mas é totalmente realizável uma vez que você domina os fundamentos.
Pontos de ação para seu próximo projeto de agente
Você tem a teoria, agora vá construir! Aqui está o que quero que você faça a seguir:
- Selecione um projeto de agente simples existente (ou comece um novo) que você construiu e que atualmente “esquece” coisas.
- Implemente `ConversationBufferMemory` para dar a ele uma memória de curto prazo básica. Veja quão mais natural a conversa se torna.
- Pense em quais conhecimentos persistentes seu agente pode precisar. É um conjunto de instruções específicas? Uma preferência pessoal? Uma base de conhecimento?
- Experimente uma configuração RAG simples. Pegue um pequeno pedaço de texto (como a persona desejada do seu agente ou alguns fatos) e armazene-o em um repositório vetorial local `FAISS`. Veja se seu agente pode recuperar e usar essa informação.
- Fique de olho em seu uso de tokens! Não se esqueça, enviar longos históricos de bate-papo ou muitos documentos recuperados aumenta sua contagem de tokens, o que impacta diretamente o custo e a latência. Otimize sua estratégia de memória ao longo do caminho.
Fazer com que seu agente IA se lembre não é apenas um detalhe técnico; é o que transforma uma interação fria e transacional em algo que parece realmente útil e inteligente. É a diferença entre uma ferramenta e um verdadeiro assistente. Vá tornar seus agentes mais inteligentes e não esqueça de compartilhar seu progresso nos fóruns agent101.net!
Artigos relacionados
- O Custo de NÃO Usar Agentes IA em 2026
- Principais Ferramentas para o Desenvolvimento de Agentes IA
- Os Fundamentos da IA: Um Guia Prático para Começar em 2026
🕒 Published: