Como Adicionar Memória ao Seu Agente com LangGraph (Passo a Passo)

“`html

Adicionando Memória ao Seu Agente com LangGraph

Estamos construindo um agente inteligente que lembra do contexto — não apenas sua última interação, mas que aprimora seu fluxo de trabalho ao acompanhar detalhes essenciais. Quando você aprende como langgraph adicionar memória ao seu agente, tudo se torna mais suave, e seu agente começa a fazer mais sentido em um processo de múltiplas etapas. Esquecer detalhes é um problema sério em aplicações de IA, e com o LangGraph, gerenciar memória pode redefinir suas interações.

Requisitos

• Python 3.11+
• pip install langgraph>=0.2.0
• Acesso à internet para instalações de pacotes e exemplos futuros

Passo 1: Configurando Seu Ambiente

Primeiro, você vai querer configurar o ambiente onde seu agente LangGraph residirá. Isso significa instalar os pacotes necessários e garantir que você está usando uma versão Python suportada.

# Atualize seu pip
pip install --upgrade pip

# Instale o LangGraph
pip install langgraph>=0.2.0

Execute esse comando no seu terminal. Se você encontrar problemas relacionados a dependências ausentes, verifique se tem a versão correta do Python instalada. Uma vez tentei usar uma versão Python depreciada, e foi um pesadelo.

Passo 2: Inicialização Básica do Agente

Com seu ambiente configurado, vamos começar a inicializar o agente. Esse agente será nossa base onde adicionaremos memória. A configuração inicial é fundamental, então precisamos garantir que tudo esteja em ordem.

from langgraph import Agent

# Inicialize o agente
agent = Agent(name="MemoryAgent", context="Você pode lembrar das minhas preferências.")

Esse código cria um agente com um contexto simples. Não é apenas qualquer contexto; trata-se de dizer ao seu agente o que ele deve lembrar. Se você se esquecer de definir o contexto corretamente, o agente pode pedir informações redundantes.

Passo 3: Adicionando Capacidade de Memória

Agora vem a parte emocionante. Para adicionar memória ao seu agente, você deve usar componentes de memória específicos fornecidos pelo LangGraph. Isso permite que seu agente armazene informações e as acesse em sessões futuras.

from langgraph.memory import Memory

# Inicialize a Memória
memory = Memory(size=10) # acompanha as últimas 10 memórias
agent.set_memory(memory) # associa a memória ao agente

Aqui, configuramos nosso agente para lembrar das últimas dez interações. Se você escolher um tamanho muito pequeno e seu agente receber muitas entradas, ele pode começar a perder informações vitais, causando confusão. Portanto, ajuste conforme necessário!

Passo 4: Ensinando o Agente a Lembrar de Contextos Específicos

Ok, configuramos a memória básica, mas qual é o ponto se seu agente não sabe o que lembrar? Vamos garantir que nosso agente aprenda informações específicas das interações.

def remember_user_preference(user_id, preference):
 agent.memory.add(f"{user_id}:{preference}") # salvando preferências do usuário

remember_user_preference("user123", "Gosta de café de manhã.")

Ao dizer explicitamente ao seu agente para lembrar de preferências específicas do usuário, ele pode personalizar a interação. Se você pular essa etapa, terá um agente brilhante, mas esquecido, que precisa constantemente das mesmas informações.

Passo 5: Recuperando Memórias

A seguir, vamos colocar essa memória em uso! Seu agente precisará recuperar memórias quando solicitado ou quando um contexto relevante surgir. Este é um ponto crucial porque os agentes devem ser interativos e responsivos.

def retrieve_memory(user_id):
 memories = agent.memory.retrieve(user_id) # recupera com base no user_id
 return memories

print(retrieve_memory("user123"))

Recuperar memória permite uma experiência personalizada. Se a função retornar None, significa que o agente ainda não salvou nada. Se você configurou a memória sem salvar nenhuma, adivinha? Você criou um chatbot glorificado.

Os Perigos

Aqui estão algumas armadilhas que podem te atrapalhar ao implementar memória com o LangGraph. Aprendi isso da maneira difícil:

“““html

• Esquecendo de Definir o Contexto: Se o contexto não for definido corretamente, seu agente não saberá o que lembrar.
• Limites de Tamanho da Memória: Se o tamanho da sua memória for muito baixo, informações importantes serão perdidas. Pense nisso como um colega de quarto ruim que joga suas coisas fora toda vez que precisa de espaço.
• Clareza do Contexto: Quanto mais claro e específico for o seu contexto, melhor será o desempenho do agente. Definições vagas levam a resultados vagos. É como dizer ao seu amigo que você “pode” querer pizza esta semana.
• Recuperação de Memória: Se codificada incorretamente, a recuperação de memória pode causar erros ou mal-entendidos, onde seu agente pode fazer afirmações falsas sobre o contexto lembrado.
• Atraso no Desempenho: Sobrecarregar seu agente com muitos dados de memória pode fazê-lo desacelerar. É como aquele amigo que, após um tempo, simplesmente não consegue acompanhar os interesses de todo mundo e começa a folhear anotações.

Exemplo Completo de Código

Aqui está o código executável completo que combina tudo o que fizemos até agora:

from langgraph import Agent
from langgraph.memory import Memory

# Passo 1: Inicializar o Agente
agent = Agent(name="MemoryAgent", context="Você pode lembrar das minhas preferências.")

# Passo 2: Configurar a Memória
memory = Memory(size=10)
agent.set_memory(memory)

# Passo 3: Função para lembrar a preferência do usuário
def remember_user_preference(user_id, preference):
 agent.memory.add(f"{user_id}:{preference}")

# Passo 4: Função para recuperar a memória
def retrieve_memory(user_id):
 memories = agent.memory.retrieve(user_id)
 return memories

# Exemplo de Uso
remember_user_preference("user123", "Gosta de café de manhã.")
print(retrieve_memory("user123"))

O que vem a seguir?

Seu próximo passo deve se concentrar em integrar esse recurso de memória em uma aplicação maior, como um chatbot de suporte ao cliente que ajusta as respostas com base em interações anteriores. Adicionar memória fará com que seus agentes sejam não apenas reativos, mas proativos!

FAQ

1. E se meu agente não lembrar de nada?

Verifique suas funções de memória e certifique-se de que você não está pulando inadvertidamente o método agent.memory.add(). É um erro amador que pode levar a frustrações!

2. Como posso limpar a memória?

Você pode redefinir a memória através de uma função claramente definida dentro do seu código de agente que limpa os dados de memória, dando a você um recomeço sempre que precisar.

3. Existe uma maneira de priorizar o que é lembrado?

Atualmente, o LangGraph não prioriza, então requer que os desenvolvedores implementem regras em torno da importância da memória de acordo com as necessidades da aplicação.

Fontes de Dados

• Documentos Oficiais do LangGraph: Visão Geral da Memória LangGraph
• Repositório do LangGraph no GitHub: langchain-ai/langgraph

Recurso	Estrelas	Forks	Problemas Abertos	Licença	Última Atualização
LangGraph	28,361	4,839	484	MIT	03 de Abril de 2026

Última atualização em 04 de Abril de 2026. Dados obtidos de documentos oficiais e benchmarks da comunidade.

“`

🕒 Published: April 5, 2026