Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Intégrer AgentCore la mémoire à 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 permettant de définir les interactions des agents avec l'utilisateur, ses outils et sa mémoire.

Il LangGraph existe deux principaux concepts de mémoire en matière de 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 est effectuée 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 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 espace de stockage permanent au sein du service, vous n'avez pas à craindre de perdre ces interactions en cas de sortie de conteneur, de solutions en mémoire peu fiables ou de pannes de l'application de l'agent.

Conditions préalables

Conditions requises avant d'intégrer AgentCore Memory à LangChain et LangGraph.

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

L'entrée AgentCoreMemorySaver LangGraph gère l'enregistrement et le 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 et thread_id RunnableConfig lors 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 est tout ce dont votre application a besoin, n'hésitez pas à ignorer 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 dans la mémoire à long terme

Pour les stockages dans 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 de la conversation. Pour les résumés, tous types HumanMessageAIMessage, et ToolMessage seraient pertinents. Il existe de nombreuses façons de procéder, mais un modèle d'implémentation 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. Alternativement, l'agent pourrait disposer d'un outil lui permettant de rechercher des informations selon ses besoins. Tous ces modèles de mise en œuvre sont pris en charge et leur 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
)

Invoquer 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