Integre AgentCore a memória com LangChain ou LangGraph

LangChain e LangGraph são estruturas poderosas de código aberto para o desenvolvimento de agentes por meio de uma arquitetura baseada em gráficos. Eles fornecem uma interface simples para definir as interações do agente com o usuário, suas ferramentas e memória.

Dentro LangGraph , existem dois conceitos principais de memória quando se trata de persistência de memória. Short-term, o contexto bruto é salvo por meio de objetos de ponto de verificação, enquanto a recuperação inteligente de memória de longo prazo é feita salvando e pesquisando nos armazenamentos de memória. Para abordar esses dois casos de uso, integrações foram criadas para cobrir tanto o fluxo de trabalho do ponto de verificação quanto o fluxo de trabalho da loja:

Essas integrações são fáceis de configurar, exigindo apenas a especificação do ID de memória de uma AgentCore memória. Como elas são salvas no armazenamento persistente dentro do serviço, não há necessidade de se preocupar em perder essas interações por meio de saídas de contêineres, soluções de memória não confiáveis ou falhas no aplicativo do agente.

Pré-requisitos

Requisitos necessários antes de integrar a AgentCore memória com LangChain e. LangGraph

Configuração para persistência de memória de curto prazo

O AgentCoreMemorySaver in LangGraph lida com todo o salvamento e carregamento do estado conversacional, do contexto de execução e das variáveis de estado ocultas por meio dos tipos de blob de AgentCore memória. Isso significa que a única configuração necessária é especificar o indicador de verificação ao compilar o gráfico do agente e, thread_id em seguida, fornecer um actor_id e RunnableConfigao invocar o agente. A configuração é mostrada abaixo e a invocação do agente é mostrada na próxima seção. Se a simples persistência da conversa for tudo o que seu aplicativo precisa, fique à vontade para pular a seção de memória de longo prazo.

# Import LangGraph and LangChain components
from langchain.chat_models import init_chat_model
from langgraph.prebuilt import create_react_agent

# Import the AgentCore Memory integrations
from langgraph_checkpoint_aws import AgentCoreMemorySaver

REGION = "us-west-2"
MEMORY_ID = "YOUR_MEMORY_ID"
MODEL_ID = "us.anthropic.claude-3-7-sonnet-20250219-v1:0"

# Initialize checkpointer for state persistence. No additional setup required.
# Sessions will be saved and persisted for actor_id/session_id combinations
checkpointer = AgentCoreMemorySaver(MEMORY_ID, region_name=REGION)

Configuração para pesquisa inteligente de memória de longo prazo

Para armazenamentos de memória de longo prazo LangGraph, você tem mais flexibilidade na forma como as mensagens são processadas. Por exemplo, se o aplicativo estiver preocupado apenas com as preferências do usuário, você só precisará armazenar os HumanMessage objetos na conversa. Para resumos, todos os tipos HumanMessageAIMessage, e ToolMessage seriam relevantes. Existem várias maneiras de fazer isso, mas um padrão comum de implementação é usar ganchos de pré e pós-modelo, conforme mostrado no exemplo abaixo. Para recuperar memórias, você pode adicionar uma store.search(query) chamada no gancho do pré-modelo e anexá-la à mensagem do usuário para que o agente tenha todo o contexto. Como alternativa, o agente pode receber uma ferramenta para pesquisar informações conforme necessário. Todos esses padrões de implementação são suportados e a implementação variará de acordo com o aplicativo.

from langgraph_checkpoint_aws import (
    AgentCoreMemoryStore
)

# Initialize store for saving and searching over long term memories
# such as preferences and facts across sessions
store = AgentCoreMemoryStore(MEMORY_ID, region_name=REGION)

# Pre-model hook runs and saves messages of your choosing to AgentCore Memory
# for async processing and extraction
def pre_model_hook(state, config: RunnableConfig, *, store: BaseStore):
    """Hook that runs pre-LLM invocation to save the latest human message"""
    actor_id = config["configurable"]["actor_id"]
    thread_id = config["configurable"]["thread_id"]

    # Saving the message to the actor and session combination that we get at runtime
    namespace = (actor_id, thread_id)

    messages = state.get("messages", [])
    # Save the last human message we see before LLM invocation
    for msg in reversed(messages):
        if isinstance(msg, HumanMessage):
            store.put(namespace, str(uuid.uuid4()), {"message": msg})
            break

    # OPTIONAL: Retrieve user preferences based on the last message and append to state
    # user_preferences_namespace = ("preferences", actor_id)
    # preferences = store.search(user_preferences_namespace, query=msg.content, limit=5)
    # # Add to input messages as needed

    return {"llm_input_messages": messages}

Crie o agente com configurações

Inicialize o LLM e crie um LangGraph agente com uma configuração de memória.

# Initialize LLM
llm = init_chat_model(MODEL_ID, model_provider="bedrock_converse", region_name=REGION)

# Create a pre-built langgraph agent (configurations work for custom agents too)
graph = create_react_agent(
    model=llm,
    tools=tools,
    checkpointer=checkpointer, # AgentCoreMemorySaver we created above
    store=store, # AgentCoreMemoryStore we created above
    pre_model_hook=pre_model_hook, # OPTIONAL: Function we defined to save user messages
    # post_model_hook=post_model_hook # OPTIONAL: Can save AI messages to memory if needed
)

Invocar o agente

Invoque o agente.

# Specify config at runtime for ACTOR and SESSION
config = {
    "configurable": {
        "thread_id": "session-1", # REQUIRED: This maps to Bedrock AgentCore session_id under the hood
        "actor_id": "react-agent-1", # REQUIRED: This maps to Bedrock AgentCore actor_id under the hood
    }
}

# Invoke the agent
response = graph.invoke(
    {"messages": [("human", "I like sushi with tuna. In general seafood is great.")]},
    config=config
)

# ... agent will answer

# Agent will have the conversation and state persisted on the next message
# Because the session ID is the same in the runtime config
response = graph.invoke(
    {"messages": [("human", "What did I just say?")]},
    config=config
)

# Define a new session in the runtime config to test long term retrieval
config = {
    "configurable": {
        "thread_id": "session-2", # New session ID
        "actor_id": "react-agent-1", # Same actor ID
    }
}

# Invoke the agent (it will retrieve long term memories from other session)
response = graph.invoke(
    {"messages": [("human", "Lets make a meal tonight, what should I cook?")]},
    config=config
)

Recursos