Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Integre AgentCore la memoria con LangChain o LangGraph

LangChain y LangGraph son potentes marcos de código abierto para desarrollar agentes mediante 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.

Dentro LangGraph hay 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 punto 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 para cubrir 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 identificador de memoria de una memoria. AgentCore Como se guardan en un almacenamiento permanente dentro del servicio, no hay necesidad de preocuparse por perder estas interacciones debido a la salida de contenedores, a soluciones en memoria poco fiables o a la caída de las aplicaciones de los agentes.

Requisitos previos

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

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

La entrada AgentCoreMemorySaver LangGraph gestiona de forma automática todo el proceso de guardar y cargar el estado de la conversación, el contexto de ejecución y las variables de estado mediante los tipos de bloques de AgentCore memoria. Esto significa que la única configuración necesaria es especificar el puntero de verificación al compilar el gráfico del agente y, a continuación, proporcionar un punto actor_id y RunnableConfig al thread_id invocar el 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 sobre la 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 los almacenes de memoria a largo plazo LangGraph, dispone 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. Hay muchas maneras de hacerlo, pero un patrón de implementación común es usar ganchos anteriores y posteriores al modelo, como se muestra en el ejemplo siguiente. Para recuperar recuerdos, puedes 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 la información que necesite. Se admiten todos estos patrones de implementación y la implementación variará según 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 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