Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Integra AgentCore la memoria con LangChain o LangGraph

LangChain e LangGraph sono potenti framework open source per lo sviluppo di agenti tramite 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 per quanto riguarda la 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 che coprono sia il flusso di lavoro del checkpoint che il flusso di lavoro del negozio:

Queste integrazioni sono facili da configurare e richiedono solo la specificazione del Memory ID di una memoria. AgentCore Poiché vengono salvate in uno spazio di archiviazione permanente 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 e. LangChain LangGraph

Configurazione per la persistenza della memoria a breve termine

L'AgentCoreMemorySaverin LangGraph gestisce automaticamente tutto il salvataggio e il caricamento dello stato della conversazione, del contesto di esecuzione e delle variabili di stato tramite 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 e thread_id quando si richiama l'agente. RunnableConfig La configurazione è mostrata di seguito e l'invocazione dell'agente è mostrata nella sezione successiva. Se la semplice persistenza della conversazione è tutto ciò di cui l'applicazione ha bisogno, sentiti libero di saltare la sezione sulla 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 una ricerca intelligente nella memoria a lungo termine

Per gli archivi di memoria a lungo termine in LangGraph, hai una maggiore flessibilità sul modo in cui i messaggi vengono elaborati. Ad esempio, se l'applicazione si occupa solo delle preferenze dell'utente, sarà necessario memorizzare solo gli HumanMessage oggetti nella conversazione. Per i riepiloghi, di tutti i tipi HumanMessageAIMessage, e ToolMessage sarebbe pertinente. Esistono numerosi modi per farlo, ma un modello di implementazione comune è l'utilizzo di hook pre e post modello, come mostrato nell'esempio seguente. Per recuperare i ricordi, puoi aggiungere una store.search(query) chiamata nell'hook pre-modello e aggiungerla al messaggio dell'utente in modo che l'agente abbia 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
)

Richiama l'agente

Invocate 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