Integrazione AgentCore della memoria con LangChain o LangGraph

LangChain e LangGraph sono potenti framework open source per lo sviluppo di agenti attraverso un'architettura basata su grafici. Forniscono un'interfaccia semplice per definire le interazioni degli agenti con l'utente, i suoi strumenti e la memoria.

All'interno LangGraph ci sono due concetti principali di memoria quando si tratta di persistenza della memoria. Short-term, il contesto non elaborato viene salvato tramite oggetti checkpoint, mentre il recupero intelligente della memoria a lungo termine viene effettuato salvando e cercando negli archivi di memoria. Per risolvere questi due casi d'uso, sono state create integrazioni per coprire sia il flusso di lavoro di checkpointing che il flusso di lavoro del negozio:

Queste integrazioni sono facili da configurare e richiedono solo la specificazione dell'ID di memoria di una memoria. AgentCore Poiché vengono salvate in uno spazio di archiviazione persistente all'interno del servizio, non è necessario preoccuparsi di perdere queste interazioni a causa di uscite dai container, soluzioni in memoria inaffidabili o arresti anomali delle applicazioni degli agenti.

Prerequisiti

Requisiti necessari prima di integrare AgentCore la memoria con and. LangChain LangGraph

Configurazione per la persistenza della memoria a breve termine

The AgentCoreMemorySaver in LangGraph gestisce tutto il salvataggio e il caricamento dello stato della conversazione, del contesto di esecuzione e delle variabili di stato sotto il cofano tramite i tipi di blob di AgentCore memoria. Ciò significa che l'unica configurazione richiesta è specificare il checkpointer durante la compilazione del grafico dell'agente, quindi fornire un actor_id e thread_id quando si richiama l'agente. RunnableConfig La configurazione è mostrata di seguito e la chiamata dell'agente è mostrata nella sezione successiva. Se la semplice persistenza della conversazione è tutto ciò di cui l'applicazione ha bisogno, non esitate a saltare la sezione relativa alla memoria a lungo termine.

# 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)

Configurazione per la ricerca intelligente nella memoria a lungo termine

Per l'archiviazione della memoria a lungo termine LangGraph, è disponibile una maggiore flessibilità nel modo in cui i messaggi vengono elaborati. Ad esempio, se l'applicazione si occupa solo delle preferenze dell'utente, è sufficiente memorizzare gli HumanMessage oggetti nella conversazione. Per i riepiloghi HumanMessageAIMessage, tutti i tipi e ToolMessage sarebbero pertinenti. Esistono numerosi modi per eseguire questa operazione, ma uno schema di implementazione comune consiste nell'utilizzare gli hook pre e post model, come illustrato nell'esempio seguente. Per il recupero delle memorie, è possibile aggiungere una store.search(query) chiamata nell'hook del modello precedente e aggiungerla al messaggio dell'utente in modo che l'agente disponga di tutto il contesto. In alternativa, all'agente potrebbe essere fornito uno strumento per cercare le informazioni necessarie. Tutti questi modelli di implementazione sono supportati e l'implementazione varierà in base all'applicazione.

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}

Crea l'agente con le configurazioni

Inizializza l'LLM e crea un LangGraph agente con una configurazione di memoria.

# 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
)

Invoca l'agente

Invoca l'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
)

Resources