Olá a todos, aqui é o Alex do agntai.net. É março de 2026, e eu tenho lutado com algo que provavelmente está na mente de muitos de vocês: como realmente construir agentes que não pareçam apenas chamadas de API glorificadas, mas que realmente apresentem algum nível de comportamento inteligente e persistente? Especificamente, eu tenho refletido muito sobre arquiteturas de memória para agentes de IA. É uma coisa conseguir que um modelo GPT responda a uma pergunta; é outra totalmente diferente ter um agente que se lembre de um projeto que durou vários dias, adapte sua estratégia com base em falhas passadas e aprenda genuinamente com as interações.
Há algum tempo, muitos de nós temos dependido fortemente de bancos de dados vetoriais como nossa memória externa principal para os agentes. E não me interpretem mal, eles são fantásticos para geração aumentada por recuperação (RAG) e para dar aos nossos agentes acesso a vastas quantidades de informações factuais ou contextuais. Mas, depois de construir alguns protótipos para clientes – um tentando ser um assistente pessoal de pesquisa, outro um bot de suporte ao cliente dinâmico – comecei a notar suas limitações. Eles são ótimos para “sobre o que conversamos na última terça-feira?” ou “quais são os recursos chave do Produto X?”, mas eles têm dificuldade com “lembra daquela preferência sutil que expressei há três semanas e integre isso à sua recomendação atual.”
Me ocorreu enquanto tentava fazer meu agente assistente de pesquisa entender que eu *realmente* não gosto de trabalhos acadêmicos excessivamente acadêmicos a menos que absolutamente necessário. Eu diria isso, ele reconheceria, então, dois dias depois, ele colocaria outro artigo denso do arXiv no meu colo. As incorporações vetoriais para “não gosto de trabalhos acadêmicos” estavam lá, mas o agente não estava realmente *aprendendo* com meu feedback de uma forma que realmente alterasse sua estratégia de busca a longo prazo. Era como conversar com alguém com ótima memória de curto prazo, mas sem memória de longo prazo para preferências pessoais ou contexto em evolução.
Além da Busca Vetorial: A Necessidade de Memória Multi-Modal
Minha conclusão? Precisamos ir além da dependência única de bancos de dados vetoriais para a memória dos agentes. Não se trata de substituí-los, mas de aumentá-los com outras formas de memória que atendam a diferentes tipos de informações e horizontes temporais. Pense em como os humanos se lembram das coisas. Temos memória de trabalho de curto prazo, memória episódica (eventos), memória semântica (fatos) e memória procedural (como fazer as coisas). Uma única incorporação vetorial de um pedaço de conversa não separa claramente essas.
O problema de confiar exclusivamente na busca vetorial para tudo é que ela trata todas as memórias como igualmente importantes e igualmente estruturadas. Uma preferência sutil, uma crença central, um objetivo de longo prazo ou uma observação transitória – todas elas são misturadas em incorporações. Quando um agente consulta sua memória, ele recupera o que é semanticamente similar, mas não necessariamente o que é *mais relevante* de uma maneira profundamente contextual ou temporalmente consciente. É como ter uma biblioteca onde cada livro é apenas uma coleção de palavras-chave, e você só pode encontrar coisas correspondendo a essas palavras-chave, não entendendo o gênero do livro, a intenção do autor ou seu lugar em uma série.
Então, como seria uma arquitetura de memória “multi-modal” para um agente de IA? Para mim, isso se resume a segregar e estruturar diferentes tipos de informações, e depois fazer com que o motor de raciocínio central do agente decida inteligentemente qual armazenamento de memória consultar e como atualizá-lo.
1. Memória de Curto Prazo / Memória de Trabalho: O Bloco de Notas
Este é o contexto imediato do seu agente. É o que o agente está ativamente pensando agora. Para mim, isso geralmente é uma lista simples de turnos recentes em uma conversa, parâmetros de tarefas atuais e observações transitórias. É volátil, é frequentemente limpo ou resumido. Pense nisso como a RAM do agente.
Exemplo: Se meu agente assistente de pesquisa está atualmente encarregado de “encontrar trabalhos sobre melhorias na arquitetura transformadora de 2024”, sua memória de trabalho contém essa consulta específica, os últimos trabalhos que revisou e talvez um sinal indicando que ele ainda está procurando. Isso é tipicamente tratado passando o histórico de conversação recente diretamente para o LLM ou mantendo-o em um simples buffer na memória.
2. Memória Episódica: O Diário de Eventos
É aqui que os bancos de dados vetoriais realmente se destacam, mas com uma reviravolta. Em vez de apenas incorporar pedaços de conversa bruta, estou achando mais útil *resumir* e *classificar* eventos antes de incorporá-los. Um “evento” pode ser uma interação do usuário, uma ação do agente, uma decisão tomada ou uma observação chave. Cada evento recebe um carimbo de data/hora, uma breve descrição e talvez algumas entidades ou sentimentos associados.
Por que resumir/taguear? Porque uma transcrição bruta da conversa pode ser muito confusa. “O usuário disse ‘isso é interessante’ depois ‘pode me mostrar mais’ e então ‘e quanto a X?’” pode ser resumido como “O usuário expressou interesse, solicitou mais informações e então perguntou sobre X.” Isso torna as incorporações mais focadas no *significado* da interação, em vez da formulação específica. Também permite uma filtragem mais fácil por tags depois.
# Código pseudo-Python para uma entrada de memória episódica
class EpisodicMemoryEntry:
def __init__(self, timestamp, description, tags=None, associated_entities=None, raw_context=None):
self.timestamp = timestamp
self.description = description # Evento resumido pelo LLM
self.tags = tags if tags is not None else []
self.associated_entities = associated_entities if associated_entities is not None else {}
self.raw_context = raw_context # Interação original para recordação detalhada se necessário
def to_embedding_text(self):
# Concatenar campos relevantes para a incorporação
return f"Evento em {self.timestamp}: {self.description}. Tags: {', '.join(self.tags)}. Entidades: {self.associated_entities}"
# Exemplo de uso:
# Supondo que 'llm_summarize_event' seja uma função que chama um LLM
# para condensar um bloco de conversa em uma descrição e extrair tags/entidades.
conversation_chunk = "Usuário: Eu realmente preciso terminar este relatório até sexta-feira. Agente: Ok, como posso ajudar? Usuário: Você pode encontrar tendências de mercado recentes para IA em saúde? Estou particularmente interessado em rodadas de financiamento."
# Chamada ao LLM para processar este bloco
summary, tags, entities = llm_summarize_event(conversation_chunk)
# resumo: "Usuário solicitou tendências de mercado recentes para IA em saúde, focando em rodadas de financiamento, com prazo para sexta-feira."
# tags: ["solicitação_de_pesquisa", "consciente_do_prazo", "saúde_IA", "rodadas_de_financiamento"]
# entidades: {"tópico": "IA em saúde", "prazo": "sexta-feira", "foco": "rodadas de financiamento"}
event = EpisodicMemoryEntry(
timestamp=datetime.now(),
description=summary,
tags=tags,
associated_entities=entities,
raw_context=conversation_chunk
)
# Então, incorpore event.to_embedding_text() e armazene no banco de dados vetorial
Quando o agente precisa recordar eventos passados, ele consulta essa memória episódica, mas agora também pode filtrar por tags, entidades ou intervalos de tempo, além da similaridade semântica.
3. Memória Semântica: O Grafo de Conhecimento de Fatos e Crenças
Esta é talvez a área mais subdesenvolvida em muitas arquiteturas de agentes, mas é onde o agente pode armazenar fatos estruturados, relações e suas próprias crenças ou preferências em evolução. Bancos de dados vetoriais são bons para fatos gerais, mas não são ótimos em representar relações (por exemplo, “Alex prefere X a Y,” “O Projeto Z é uma subtarefa do Projeto A”).
É aqui que comecei a experimentar com grafos de conhecimento. Em vez de apenas incorporar tudo, estou usando LLMs para extrair triplas (sujeito-predicado-objeto) de interações e armazená-las em um banco de dados gráfico (como Neo4j ou até mesmo um banco de dados relacional simples se o grafo não for muito complexo).
Por que um grafo de conhecimento? Porque ele modela explicitamente relações. Se meu agente aprende “Alex não gosta de documentos acadêmicos,” essa é uma relação direta. Se ele aprende então “Documentos de IA em saúde são frequentemente acadêmicos,” pode inferir “Alex provavelmente não gosta de documentos de IA em saúde.” Esse tipo de inferência é difícil apenas com similaridade vetorial.
# Código pseudo-Python para extrair e armazenar triplas
def extract_and_store_triples(agent_id, text_input):
# Chamada LLM para extrair triplas.
# Prompt: "Extraia triplas factuais (sujeito, predicado, objeto) do seguinte texto.
# Exemplo: 'Alex prefere café' -> (Alex, prefere, café)."
# text_input = "O usuário Alex mencionou que prefere resumos concisos e não gosta de artigos excessivamente acadêmicos."
triples_str = call_llm_for_triple_extraction(text_input)
# Saída de exemplo: "[(Alex, prefere, resumos concisos), (Alex, não gosta, artigos acadêmicos)]"
extracted_triples = parse_triples_string(triples_str) # Converte a string em uma lista de tuplas
for s, p, o in extracted_triples:
# Armazenar em um banco de dados gráfico (por exemplo, usando um dicionário Python simples para demonstração)
# Em um sistema real, isso seria uma chamada de cliente Neo4j ou similar
graph_db_add_triple(agent_id, s, p, o)
# Exemplo de 'graph_db_add_triple' (simplificado)
knowledge_graph = {} # {sujeito: {predicado: [objetos]}}
def graph_db_add_triple(agent_id, s, p, o):
if agent_id not in knowledge_graph:
knowledge_graph[agent_id] = {}
if s not in knowledge_graph[agent_id]:
knowledge_graph[agent_id][s] = {}
if p not in knowledge_graph[agent_id][s]:
knowledge_graph[agent_id][s][p] = []
if o not in knowledge_graph[agent_id][s][p]: # Prevenir duplicatas
knowledge_graph[agent_id][s][p].append(o)
# Para consultar:
# O que Alex não gosta? -> knowledge_graph[agent_id]["Alex"]["não gosta"]
O agente pode consultar esse gráfico não apenas por palavras-chave, mas por relacionamentos. “Quais são as preferências de Alex?” ou “Quais tarefas estão relacionadas ao Projeto A?” Essa é uma forma muito mais poderosa de recuperar conhecimento estruturado.
4. Memória Procedimental: A Biblioteca de Habilidades
Isso não é memória no sentido tradicional, mas sim uma coleção de ferramentas, funções e fluxos de trabalho que o agente sabe executar. Quando um LLM decide que precisa realizar uma ação, ele consulta essa “biblioteca de habilidades.” Isso pode ser uma lista de funções Python, especificações de APIs ou até mesmo fluxos de trabalho de múltiplas etapas pré-definidos.
Minha experiência: Eu achei útil tornar essas habilidades descobríveis pelo LLM usando docstrings descritivas e assinaturas de funções claras. O LLM pode então escolher a ferramenta certa com base no objetivo atual.
class AgentSkills:
def search_web(self, query: str) -> str:
"""
Pesquisa na web informações relacionadas à consulta.
Útil para conhecimento geral, notícias e eventos atuais.
Args:
query (str): A consulta de busca.
Returns:
str: Um resumo dos resultados da pesquisa.
"""
# ... implementação real da pesquisa na web ...
return f"Resultados da pesquisa na web para '{query}': ..."
def analyze_document(self, document_id: str, analysis_type: str) -> str:
"""
Analisa um documento especificado para várias percepções.
Útil para resumir, extrair pontos-chave ou fazer análise de sentimento de um documento.
Args:
document_id (str): O ID do documento a ser analisado.
analysis_type (str): O tipo de análise a ser realizada (por exemplo, 'resumo', 'palavras-chave', 'sentimento').
Returns:
str: O resultado da análise.
"""
# ... implementação da análise do documento ...
return f"Análise do documento {document_id} para {analysis_type}: ..."
def get_user_preferences(self, user_id: str, preference_type: str = None) -> dict:
"""
Recupera preferências armazenadas para um usuário específico.
Útil para personalizar respostas e ações.
Args:
user_id (str): O ID do usuário.
preference_type (str, opcional): Tipo específico de preferência a ser recuperada (por exemplo, 'não gosta', 'tópicos').
Returns:
dict: Um dicionário de preferências do usuário.
"""
# Isso consultaria a memória semântica (gráfico de conhecimento)
# Para simplicidade, retornando dados simulados aqui
if user_id == "Alex" and preference_type == "não gosta":
return {"não gosta": ["artigos acadêmicos", "explicações verbosas"]}
return {"preferências": "..."}
# O LLM seria solicitado a selecionar e chamar essas funções com base em seu raciocínio.
Colocando Tudo Junto: A Camada de Orquestração
A verdadeira mágica acontece na maneira como o motor de raciocínio central do agente (o próprio LLM, tipicamente) interage com esses diferentes armazenamentos de memória. Não é apenas um sistema passivo de recuperação; o agente precisa decidir ativamente:
- Que informação eu preciso agora?
- Qual armazenamento de memória é mais provável que contenha essa informação?
- Como devo atualizar minha memória com base nessa nova interação/observação?
Esse processo de tomada de decisão é onde o agente realmente se torna dinâmico. Eu costumo estruturar isso com um prompt que orienta o LLM a pensar em voz alta, planejar e, em seguida, executar operações de memória. É uma cadeia de processos de pensamento que incorpora interação com a memória.
Minha abordagem atual:
- Perceber: O agente recebe a entrada (consulta do usuário, evento do sistema).
- Refletir & Planejar: O LLM analisa a entrada, considera os objetivos atuais e formula um plano. Esse plano muitas vezes envolve consultar a memória.
- “Eu preciso relembrar interações passadas (epidódicas)? Quais são as preferências conhecidas do usuário (semânticas)? Eu tenho ferramentas para alcançar isso (procedurais)?”
- Pode consultar a memória epidódica para situações passadas semelhantes ou a memória semântica para fatos relevantes.
- Atuar: Com base no plano e nas memórias recuperadas, o LLM decide uma ação (por exemplo, gerar uma resposta, chamar uma ferramenta, atualizar a memória).
- Memorizar & Aprender: Após uma ação, o LLM reflete sobre o resultado e atualiza seus diversos armazenamentos de memória.
- Uma nova interação é resumida e adicionada à memória epidódica.
- Novos fatos ou preferências são extraídos e adicionados ao grafo de conhecimento semântico.
- Se uma estratégia falhou, pode gerar uma entrada de “lição aprendida” na memória semântica.
Esse processo iterativo permite que o agente construa uma compreensão mais rica e sutil de seu ambiente, de seu usuário e de si mesmo ao longo do tempo. Ele vai além de simplesmente recuperar fatos para realmente formar crenças persistentes e adaptar seu comportamento.
Conclusões Acionáveis para a Arquitetura do Seu Agente
Se você está construindo agentes de IA agora e atingindo os limites do RAG simples, aqui está o que eu recomendo tentar:
- Não trate toda memória como igual. Categorize o tipo de informação que você precisa armazenar: contexto de curto prazo, histórico de eventos, fatos/preferências estruturados e capacidades.
- Aumente seu banco de dados vetorial. É ótimo para a memória epidódica, especialmente quando você resume e marca as entradas. Mas não faça disso o único armazenamento de memória.
- Experimente gráficos de conhecimento para memória semântica. Mesmo um simples armazenamento de triplas pode fazer uma grande diferença em como seu agente armazena e recupera relacionamentos estruturados e crenças centrais. Isso permite uma verdadeira inferência, não apenas a busca por similaridade.
- Projete para uma gestão ativa da memória. O mecanismo de raciocínio central do agente (seu prompt LLM) deve incluir explicitamente etapas para consultar, atualizar e refletir sobre seus diferentes armazenamentos de memória. Não jogue todo o contexto em um único prompt.
- Mantenha a memória procedural (uso de ferramentas) organizada. Descrições claras e exemplos para suas ferramentas ajudam o LLM a usar efetivamente suas capacidades.
Construir agentes realmente inteligentes não é apenas sobre modelos maiores; é sobre arquiteturas mais inteligentes. Ao dar aos nossos agentes um sistema de memória mais semelhante ao humano, podemos nos aproximar de agentes que não apenas lembram, mas realmente aprendem e se adaptam. É um caminho desafiador, mas incrivelmente recompensador, e estou animado para ver aonde todos nós levaremos isso a seguir.
🕒 Published: