Intégrer AgentCore la mémoire avec LangChain ou LangGraph

LangChain et LangGraph sont de puissants frameworks open source permettant de développer des agents via une architecture basée sur des graphes. Ils fournissent une interface simple pour définir les interactions de l'agent avec l'utilisateur, ses outils et sa mémoire.

Il LangGraph existe deux concepts principaux de mémoire en ce qui concerne la persistance de la mémoire. Short-term, le contexte brut est enregistré via des objets de point de contrôle, tandis que la récupération intelligente de la mémoire à long terme s'effectue en enregistrant et en recherchant dans les mémoires. Pour répondre à ces deux cas d'utilisation, des intégrations ont été créées pour couvrir à la fois le flux de travail de point de contrôle et le flux de travail du magasin :

Ces intégrations sont faciles à configurer, il suffit de spécifier l'ID de mémoire d'une AgentCore mémoire. Comme elles sont enregistrées dans un stockage permanent au sein du service, il n'y a pas lieu de craindre de perdre ces interactions en raison de sorties de conteneurs, de solutions en mémoire peu fiables ou de pannes d'applications d'agent.

Conditions préalables

Exigences dont vous avez besoin avant d'intégrer AgentCore la mémoire à LangChain et LangGraph.

Configuration pour la persistance de la mémoire à court terme

L'entrée AgentCoreMemorySaver LangGraph gère toutes les opérations d'enregistrement et de chargement de l'état conversationnel, du contexte d'exécution et des variables d'état sous le capot via les types de blob de AgentCore mémoire. Cela signifie que la seule configuration requise est de spécifier le pointeur de contrôle lors de la compilation du graphe de l'agent, puis de fournir un actor_id and thread_id RunnableConfiglors de l'appel de l'agent. La configuration est présentée ci-dessous et l'invocation de l'agent est présentée dans la section suivante. Si la simple persistance des conversations suffit à votre application, n'hésitez pas à sauter la section sur la mémoire à long terme.

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

Configuration pour une recherche intelligente de mémoire à long terme

Pour le stockage de la mémoire à long terme LangGraph, vous disposez d'une plus grande flexibilité quant à la manière dont les messages sont traités. Par exemple, si l'application ne concerne que les préférences de l'utilisateur, il vous suffira de stocker les HumanMessage objets dans la conversation. Pour les résumés, tous les types HumanMessageAIMessage, et ToolMessage seraient pertinents. Il existe de nombreuses façons de procéder, mais un modèle de mise en œuvre courant consiste à utiliser des hooks avant et après le modèle, comme le montre l'exemple ci-dessous. Pour récupérer des souvenirs, vous pouvez ajouter un store.search(query) appel dans le hook pré-modèle et l'ajouter au message de l'utilisateur afin que l'agent dispose de tout le contexte. Il est également possible de fournir à l'agent un outil lui permettant de rechercher des informations selon les besoins. Tous ces modèles de mise en œuvre sont pris en charge et la mise en œuvre varie en fonction de l'application.

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}

Création de l'agent avec des configurations

Initialisez le LLM et créez un LangGraph agent avec une configuration de mémoire.

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

Invoquez l'agent

Invoquez l'agent.

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

Ressources