Mergulhe fundo na memória corporal inteligente de IA: dos conceitos básicos às práticas de LangGraph

A experiência de se comunicar com um amigo que sempre esquece o conteúdo da conversa e precisa começar do início todas as vezes é, sem dúvida, ineficiente e exaustiva. No entanto, essa é exatamente a norma para a maioria dos sistemas de IA atuais. Eles são poderosos, mas geralmente está faltando um elemento fundamental:memorização.

A memória não é um complemento opcional, mas uma base fundamental para a criação de inteligências (agentes) de IA que possam realmente aprender, evoluir e colaborar.

Conceitos básicos de memória de IA

O atual dilema da "apatridia" da IA

comparável ChatGPT Ou ferramentas como assistentes de código que, apesar de seu poder, forçam os usuários a repetir instruções ou preferências várias vezes. Essa "ilusão de memória", criada pelas janelas contextuais do modelo de linguagem grande e da Prompt Engineering, levou as pessoas a acreditarem que a IA já tem a capacidade de se lembrar.

De fato, a grande maioria das inteligências de IA é essencialmente **Autônoma**.s, eles não podem aprender com as interações passadas nem se adaptar ao longo do tempo. Para evoluir de ferramentas sem estado para ferramentas verdadeiramente autônomasAs inteligências com estado** precisariam ser dotadas de mecanismos reais de memória, em vez de simplesmente expandir a janela de contexto ou otimizar os recursos de recuperação.

O que são exatamente as memórias nas inteligências de IA?

No contexto das inteligências de IA, a memória é a capacidade de reter e recuperar informações relevantes ao longo do tempo, das tarefas e das sessões. Ela permite que as inteligências se lembrem das interações históricas e usem essas informações para orientar o comportamento futuro.

A verdadeira memória é muito mais do que armazenar bate-papos. Trata-se de criar um estado interno em constante evolução que afeta todas as decisões tomadas pela inteligência, mesmo que duas interações tenham ocorrido com semanas de diferença.

A memória de um corpo inteligente é definida por três pilares:

• EstadoInformações instantâneas sobre a interação atual: percebem informações instantâneas sobre a interação atual.
• PersistênciaRetenção de conhecimento de longo prazo entre sessões.
• SeletividadeDeterminar quais informações valem a pena ser lembradas por um longo período.

Juntos, esses três pilares formam a base para que as inteligências alcancem a **Continuidade**.

Janelas contextuais, RAG e diferenças de memória

Os componentes típicos para colocar a memória na arquitetura principal das inteligências incluem modelos de linguagem ampla (LLMs), planejadores (como ReAct frameworks), conjuntos de ferramentas (APIs) e recuperadores. O problema é que nenhum desses componentes consegue se lembrar do que aconteceu ontem.

Janela de contexto ≠ Memória

Uma concepção errônea comum é que uma janela contextual cada vez maior pode substituir completamente a memorização. No entanto, há um claro gargalo nessa abordagem:

• alto custo：更多的 Tokens 意味着更高的计算成本和延迟。
• Informações limitadasArmazenamento persistente entre sessões não é possível e todas as informações contextuais são perdidas quando a sessão termina.
• Falta de priorizaçãoInformações de contexto: Todas as informações têm o mesmo status no contexto e não é possível distinguir entre informações críticas e transitórias.

A janela de contexto garante que as inteligências noEm uma única sessãode coerência, enquanto a memória lhe dásessão cruzadaA inteligência.

RAG ≠ Memória

Geração de aprimoramento de recuperação (RAG) e os sistemas de memória também informam o LLM, mas eles resolvem problemas muito diferentes.RAG Ao raciocinar, as informações factuais são recuperadas de bases de conhecimento externas (por exemplo, documentos, bancos de dados) e injetadas com palavras-chave para aumentar a precisão da resposta. No entanto RAG é sem estado, não se preocupa com a identidade do usuário e não pode correlacionar a consulta atual com o histórico de conversas.

A memória, por outro lado, traz continuidade. Ela registra as preferências do usuário, as decisões históricas, os sucessos e os fracassos e utiliza essas informações em interações futuras.

Resumidamente:RAG Ajuda as inteligências a responder com mais precisão, e as memórias ajudam as inteligências a agir com mais inteligência. Uma inteligência madura exige que ambos trabalhem juntos:RAG fornecem a eles conhecimento externo, e a memória molda seu comportamento interno.

Para distinguir entre os três com mais clareza, consulte a tabela abaixo:

IA Tipos de memória

A memória nas inteligências de IA pode ser dividida em duas formas básicas: memória de curto prazo e memória de longo prazo, que servem a diferentes funções cognitivas.

• Memória de curto prazoPreservação do contexto imediato em uma única interação, como na memória de trabalho humana.
• Memória de longo prazoRetenção de conhecimento em sessões, tarefas e tempo para aprendizado e adaptação.

memória de curto prazo

A memória de curto prazo, também conhecida como memória de trabalho, é a forma mais básica de memória para sistemas de IA, usada para manter o contexto imediato, inclusive:

• Diálogo com a históriaMensagens recentes e sua ordem.
• estado provisórioVariáveis temporárias durante a execução de uma tarefa.
• Foco de atençãoO núcleo atual do diálogo.

Memória de longo prazo

Os aplicativos de IA mais complexos precisarão implementar a memória de longo prazo para retenção de conhecimento e personalização entre as sessões. A memória de longo prazo consiste em três tipos principais:

1. memória processual

Essa é a "memória muscular" da inteligência, ou seja, a inteligência sabe queComo fazer issoAlgo. Ele define as ações que a inteligência pode executar, codificadas diretamente na lógica. Por exemplo, "Use um estilo explicativo mais detalhado ao responder a perguntas técnicas" ou "Sempre priorize e-mails de supervisores específicos".

2 Memória episódica

Esse é o "álbum de interações" da inteligência, que registra o histórico de interações e eventos específicos relacionados a um determinado usuário. É a chave para a personalização, a continuidade e o aprendizado de longo prazo. Por exemplo, uma inteligência pode lembrar que "da última vez que um cliente perguntou sobre um problema de cobrança, uma resposta lenta levou à insatisfação", de modo que possa otimizar sua estratégia de resposta no futuro.

3. memória semântica

Essa é a "enciclopédia factual" da inteligência, armazenando fatos objetivos sobre o mundo e o usuário. Esse conhecimento geralmente é recuperado por meio de pesquisas vetoriais ou RAG A pesquisa é realizada independentemente da interação específica. Por exemplo, "Alice é a líder técnica do projeto A" ou "O fuso horário de trabalho de John é PST".

Mecanismos de implementação de memória de IA

Tempo de gravação da memória

Quando e como as inteligências criam novas memórias? Há duas abordagens principais:

1. Gravação sincronizada em tempo realCriar e atualizar memórias em tempo real à medida que elas interagem com o usuário. Essa abordagem permite que novas memórias entrem em vigor imediatamente, mas também pode adicionar latência e complexidade à lógica principal do aplicativo. Por exemplo.ChatGPT Um mecanismo semelhante é usado pela função de memória do save_memories A ferramenta toma decisões em tempo real sobre salvar ou não as informações em um diálogo.
2. Processamento assíncrono em segundo planoGerenciamento de memória: Lide com a criação e a organização da memória como tarefas separadas em segundo plano. Essa abordagem desacopla o gerenciamento da memória da lógica principal do aplicativo, reduzindo a latência e permitindo um processamento off-line mais complexo, como o resumo e a desduplicação de informações.

Estratégias de gerenciamento da memória

Quando os diálogos são muito longos, a memória de curto prazo pode exceder os limites da janela de contexto do LLM. As estratégias comuns de gerenciamento incluem:

• corteRemover as primeiras ou últimas N mensagens do histórico de diálogo.
• resumosResumo: Resuma o diálogo anterior e substitua o texto original por um resumo.
• esquecimento seletivoExclusão permanente de parte da memória com base em regras predefinidas (por exemplo, filtragem de mensagens não importantes do sistema) ou julgamento do modelo.

O desafio de alcançar a memória de IA

Embora a memória seja vital para a inteligência, ela enfrenta muitos desafios na prática:

• Sobrecarga de memória e mecanismos de esquecimentoAs memórias acumuladas infinitamente podem tornar um sistema inchado e ineficiente. É um desafio projetar mecanismos de esquecimento eficazes que permitam que as inteligências esqueçam informações obsoletas ou irrelevantes.
• poluição de informaçõesInformações falsas ou maliciosas podem ser armazenadas na memória de longo prazo, "contaminando" o sistema de tomada de decisões da inteligência e levando a um comportamento futuro tendencioso.
• Privacidade e segurançaInformações confidenciais do usuário: Uma grande quantidade de informações confidenciais do usuário, como preferências, histórico e dados pessoais, é armazenada na memória de longo prazo. Como garantir a criptografia, o controle de acesso e a conformidade desses dados é fundamental para que o aplicativo saia do papel.
• Custo e desempenhoManutenção de armazenamentos de memória em grande escala e execução de operações complexas de recuperação e gravação geram custos adicionais de computação e armazenamento e podem afetar a capacidade de resposta do sistema.

Usando LangGraph para criar corpos inteligentes com memória

LangGraph é uma estrutura avançada para a criação de aplicativos com estado e inteligência múltipla, com suporte natural para loops e gerenciamento de estado, ideal para a implementação de sistemas de memória complexos. O exemplo de código a seguir mostrará como usar o LangGraph Acrescentar a memória de curto e longo prazo às inteligências.

Acréscimo de memória de curto prazo

A memória de curto prazo (persistência em nível de thread) permite que as inteligências mantenham o controle de um único diálogo de várias rodadas. Isso é possível com o fornecimento de uma memória de curto prazo para a LangGraph A figura configura um ponteiro de verificação que facilita o salvamento e o carregamento automático do estado.

O exemplo a seguir usa um ponto de verificação de memória InMemorySaver para salvar o estado da sessão.

from langchain_community.chat_models import ChatAnthropic # 假设使用Anthropic模型
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.checkpoint.memory import InMemorySaver
# 为简化，假设模型已初始化
# model = ChatAnthropic(model="claude-3-5-sonnet-20240620")
# 实际使用时请替换为真实模型
class FakeModel:
def invoke(self, messages):
from langchain_core.messages import AIMessage
last_message = messages[-1].content
if "bob" in last_message:
return AIMessage(content="Hi Bob! How can I help you today?")
elif "my name" in last_message:
return AIMessage(content="Your name is Bob.")
else:
return AIMessage(content="Hello there!")
model = FakeModel()
def call_model(state: MessagesState):
response = model.invoke(state["messages"])
return {"messages": [response]}
builder = StateGraph(MessagesState)
builder.add_node("call_model", call_model)
builder.add_edge(START, "call_model")
checkpointer = InMemorySaver()
graph = builder.compile(checkpointer=checkpointer)
# 使用唯一的 thread_id 来标识一个独立的对话线程
config = {
"configurable": {
"thread_id": "user_1_thread_1"
}
}
# 第一次交互
for chunk in graph.stream(
{"messages": [{"role": "user", "content": "Hi! I'm Bob."}]},
config,
stream_mode="values",
):
chunk["messages"][-1].pretty_print()
# 第二次交互，在同一线程中
for chunk in graph.stream(
{"messages": [{"role": "user", "content": "What's my name?"}]},
config,
stream_mode="values",
):
chunk["messages"][-1].pretty_print()

================================== Ai Message ==================================
Hi Bob! How can I help you today?
================================== Ai Message ==================================
Your name is Bob.

Em um ambiente de produção, o InMemorySaver Substitua o back-end do banco de dados por um persistente, como PostgresSaver talvez MongoDBSaverpara garantir que o estado do diálogo não seja perdido depois que o serviço for reiniciado.

Pontos de controle de gerenciamento

LangGraph Fornece uma interface para gerenciar pontos de controle (ou seja, estado da sessão).

Visualizar o estado atual do thread:

# graph.get_state(config)

Visualizar todos os status históricos do tópico:

# list(graph.get_state_history(config))

Adicionando memória de longo prazo

A memória de longo prazo (persistência entre threads) é usada para armazenar dados que precisam ser retidos por um longo período, como as preferências do usuário.LangGraph Permite que um gráfico compilado receba um store para essa funcionalidade.

O exemplo a seguir mostra como usar o InMemoryStore Armazena informações do usuário e as compartilha em diferentes threads de diálogo.

import uuid
from typing_extensions import TypedDict
from langchain_core.runnables import RunnableConfig
from langgraph.store.base import BaseStore
from langgraph.store.memory import InMemoryStore
# ... (复用之前的模型和 State 定义) ...
def call_model_with_long_term_memory(
state: MessagesState,
config: RunnableConfig,
*,
store: BaseStore,
):
from langchain_core.messages import AIMessage, SystemMessage
user_id = config["configurable"]["user_id"]
namespace = ("memories", user_id)
# 检索长期记忆
memories = store.search(query="", namespace=namespace)
info = "\n".join([d.value["data"] for d in memories])
system_msg_content = f"You are a helpful assistant. User info: {info}"
# 写入长期记忆
last_message = state["messages"][-1]
if "remember" in last_message.content.lower():
memory_to_save = "User's name is Bob"
# 使用唯一ID存储记忆
store.put([(str(uuid.uuid4()), {"data": memory_to_save})], namespace=namespace)
# 调用模型
response = model.invoke([SystemMessage(content=system_msg_content)] + state["messages"])
return {"messages": [response]}
builder_ltm = StateGraph(MessagesState)
builder_ltm.add_node("call_model", call_model_with_long_term_memory)
builder_ltm.add_edge(START, "call_model")
checkpointer_ltm = InMemorySaver()
store = InMemoryStore()
graph_ltm = builder_ltm.compile(
checkpointer=checkpointer_ltm,
store=store,
)
# 在线程1中，用户要求记住名字
config1 = {
"configurable": {
"thread_id": "thread_1",
"user_id": "user_123",
}
}
for chunk in graph_ltm.stream(
{"messages": [{"role": "user", "content": "Hi! Please remember my name is Bob"}]},
config1,
stream_mode="values",
):
chunk["messages"][-1].pretty_print()
# 在新的线程2中，查询名字
config2 = {
"configurable": {
"thread_id": "thread_2",
"user_id": "user_123", # 相同的 user_id
}
}
for chunk in graph_ltm.stream(
{"messages": [{"role": "user", "content": "What is my name?"}]},
config2,
stream_mode="values",
):
chunk["messages"][-1].pretty_print()

================================== Ai Message ==================================
Hi Bob! How can I help you today?
================================== Ai Message ==================================
Your name is Bob.

Habilitar a pesquisa semântica

Ao fornecer store A configuração do modelo de incorporação de vetores permite a recuperação de memória baseada em similaridade semântica, permitindo que as inteligências acessem informações relevantes de forma mais inteligente.

from langchain_openai import OpenAIEmbeddings
# 假设已初始化 OpenAIEmbeddings
# embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
# store = InMemoryStore(
#     index={
#         "embed": embeddings,
#         "dims": 1536, # 嵌入维度
#     }
# )
# 
# store.put([
#     ("1", {"text": "I love pizza"}),
#     ("2", {"text": "I am a plumber"})
# ], namespace=("user_123", "memories"))
# 在调用时，通过 query 参数进行语义搜索
# items = store.search(
#     query="I'm hungry",
#     namespace=("user_123", "memories"),
#     limit=1
# )
# 搜索结果将是与 "I'm hungry" 最相关的 "I love pizza"。

Esse recurso permite que as inteligências recuperem dinamicamente as informações mais relevantes do banco de memória com base no contexto do diálogo, em vez de simplesmente fazer a correspondência de palavras-chave.

Estudo de caso: Criação de um corpo de inteligência de e-mail com memória aprimorada

A seguir, a teoria é colocada em prática com a construção de uma inteligência de processamento de correio eletrônico com vários tipos de memórias.

7.1 Definição dos estados do corpo inteligente

Primeiro, defina os estados que as inteligências precisam controlar, abrangendo a memória de curto e longo prazo.

from typing import TypedDict, Dict, Any
from langgraph.graph import MessagesState
class EmailAgentState(TypedDict, total=False):
"""邮件智能体的状态定义"""
messages: MessagesState  # 短期记忆：对话历史
user_preferences: Dict[str, Any]  # 长期语义记忆：用户偏好
email_threads: Dict[str, Any]  # 长期情景记忆：历史邮件线程
action: str # 决策动作
reply: str # 生成的回复

7.2 Implementação de um classificador de decisão (usando memória situacional)

Crie um nó classificador que determine a próxima ação com base no conteúdo do e-mail e nas interações históricas (memória situacional).

def classify_email(state: EmailAgentState):
# 此处应调用 LLM 进行分类
# 为简化，直接返回一个硬编码的决策
email_content = state["messages"][-1].content
if "urgent" in email_content.lower():
return {"action": "escalate"}
return {"action": "reply"}

7.3 Definição de ferramentas (usando memória semântica)

Defina as ferramentas disponíveis para as inteligências, por exemplo, informações de contato da memória semântica.

from langgraph.prebuilt import ToolNode
def get_contacts_from_memory(user_id: str):
# 模拟从用户数据库或语义记忆中获取联系人
contacts_db = {
"user_123": {
"developers": ["alice@company.com"],
"managers": ["charlie@company.com"]
}
}
return contacts_db.get(user_id, {})
def send_email(to: str, subject: str, body: str):
# 模拟发送邮件API
print(f"Email sent to {to} with subject '{subject}'")
return "Email sent successfully."
tools = [get_contacts_from_memory, send_email]
tool_node = ToolNode(tools)

7.4 Construção de um gráfico e conexão de nós

fazer uso de LangGraph Conecte todos os componentes em um fluxo de trabalho executável.

from langgraph.graph import StateGraph, START, END
builder = StateGraph(EmailAgentState)
# 1. 定义节点
builder.add_node("classify", classify_email)
builder.add_node("generate_reply", lambda state: {"reply": "Generated reply based on user tone."}) # 简化版
builder.add_node("escalate_task", lambda state: print("Task Escalated!"))
# 2. 定义边
builder.add_edge(START, "classify")
builder.add_conditional_edges(
"classify",
lambda state: state["action"],
{
"reply": "generate_reply",
"escalate": "escalate_task",
}
)
builder.add_edge("generate_reply", END)
builder.add_edge("escalate_task", END)
# 3. 编译图
email_graph = builder.compile()

Esse exemplo simplificado mostra como a combinação de diferentes tipos de memórias (por meio de estados e ferramentas) pode impulsionar o fluxo de trabalho de uma inteligência. Ao ampliar essa estrutura, é possível criar assistentes de IA avançados, capazes de lidar com tarefas complexas, altamente personalizados e com capacidade de aprendizado contínuo.

As perguntas a seguir podem servir como um guia eficaz para se pensar ao projetar suas próprias inteligências que aprimoram a memória:

1. Conteúdo de aprendizado: Que tipo de informação as inteligências devem aprender? São fatos objetivos, resumos de eventos históricos ou regras de comportamento?
2. Hora de lembrarQuando e por quem a formação da memória deve ser acionada? É na interação em tempo real ou no processamento em lote em segundo plano?
3. Soluções de armazenamento: Onde as memórias devem ser armazenadas? É um banco de dados local, armazenamento vetorial ou um serviço de nuvem?
4. Segurança e privacidadeComo os dados da memória podem ser protegidos contra vazamento e uso indevido?
5. Atualizações e manutençãoComo você evita que memórias desatualizadas ou defeituosas contaminem a tomada de decisões de uma inteligência?