Integre AgentCore la memoria con LangChain o LangGraph

LangChain y LangGraph son potentes marcos de código abierto para desarrollar agentes a través de una arquitectura basada en gráficos. Proporcionan una interfaz sencilla para definir las interacciones de los agentes con el usuario, sus herramientas y su memoria.

LangGraph Existen dos conceptos principales de memoria en lo que respecta a la persistencia de la memoria. Short-term, el contexto sin procesar se guarda mediante objetos de puntos de control, mientras que la recuperación inteligente de la memoria a largo plazo se realiza guardando y buscando en los almacenes de memoria. Para abordar estos dos casos de uso, se crearon integraciones que abarcaran tanto el flujo de trabajo de los puntos de control como el flujo de trabajo de la tienda:

Estas integraciones son fáciles de configurar y solo requieren especificar el ID de memoria de una memoria. AgentCore Como se guardan en un almacenamiento persistente dentro del servicio, no hay necesidad de preocuparse por perder estas interacciones a causa de la salida de los contenedores, las soluciones en memoria poco fiables o los bloqueos de las aplicaciones de los agentes.

Requisitos previos

Requisitos que necesita antes de integrar la AgentCore memoria con y. LangChain LangGraph

Configuración para la persistencia de la memoria a corto plazo

La entrada AgentCoreMemorySaver LangGraph gestiona todo el almacenamiento y la carga de las variables de estado de la conversación, el contexto de ejecución y el estado de forma clandestina mediante tipos de blob de AgentCore memoria. Esto significa que la única configuración necesaria es especificar el punto de control al compilar el gráfico del agente y, a continuación, proporcionar una actor_id y thread_id en el al invocar RunnableConfigal agente. La configuración se muestra a continuación y la invocación del agente se muestra en la siguiente sección. Si lo único que necesita su aplicación es una simple persistencia en la conversación, no dude en saltarse la sección de memoria a largo plazo.

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

Configuración para la búsqueda inteligente de memoria a largo plazo

En el caso de las memorias almacenadas a largo plazo LangGraph, dispondrá de más flexibilidad a la hora de procesar los mensajes. Por ejemplo, si la aplicación solo se ocupa de las preferencias del usuario, solo necesitará almacenar los HumanMessage objetos de la conversación. Para los resúmenes, de todos los tipos HumanMessageAIMessage, y ToolMessage sería relevante. Existen numerosas formas de hacerlo, pero un patrón de implementación común es usar ganchos anteriores y posteriores al modelo, como se muestra en el siguiente ejemplo. Para recuperar recuerdos, puede añadir una store.search(query) llamada en el enlace anterior al modelo y añadirla al mensaje del usuario para que el agente tenga todo el contexto. Como alternativa, se le podría proporcionar al agente una herramienta para buscar información según sea necesario. Se admiten todos estos patrones de implementación y la implementación variará en función de la aplicación.

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}

Cree el agente con las configuraciones

Inicialice el LLM y cree un LangGraph agente con una configuración de 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 al agente

Invoca al 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