AgentCore Speicher integrieren mit LangChain oder LangGraph

LangChain und LangGraph sind leistungsstarke Open-Source-Frameworks für die Entwicklung von Agenten mithilfe einer graphbasierten Architektur. Sie bieten eine einfache Oberfläche zur Definition von Agenteninteraktionen mit dem Benutzer, seinen Tools und seinem Speicher.

Darin LangGraph gibt es zwei grundlegende Speicherkonzepte, wenn es um Speicherpersistenz geht. Short-termwird der Rohkontext mithilfe von Checkpoint-Objekten gespeichert, während der intelligente Langzeitspeicherabruf durch Speichern und Durchsuchen von Speicherspeichern erfolgt. Um diesen beiden Anwendungsfällen gerecht zu werden, wurden Integrationen entwickelt, die sowohl den Checkpoint-Workflow als auch den Store-Workflow abdecken:

Diese Integrationen sind einfach einzurichten und erfordern lediglich die Angabe der Speicher-ID eines Speichers. AgentCore Da sie innerhalb des Dienstes auf einem persistenten Speicher gespeichert werden, müssen Sie sich keine Sorgen machen, dass diese Interaktionen durch Container-Exits, unzuverlässige In-Memory-Lösungen oder Abstürze von Agentenanwendungen verloren gehen könnten.

Voraussetzungen

Anforderungen, die Sie vor der Integration von AgentCore Memory mit und benötigen. LangChain LangGraph

Konfiguration für Kurzzeitgedächtnispersistenz

Der AgentCoreMemorySaver in LangGraph verarbeitet das gesamte Speichern und Laden von Konversationsstatus-, Ausführungskontext- und Zustandsvariablen unter der Haube über AgentCore Speicherblob-Typen. Das bedeutet, dass die einzige Einrichtung, die erforderlich ist, darin besteht, beim Kompilieren des Agentendiagramms den Checkpointer anzugeben und dann RunnableConfigbeim Aufrufen des Agenten ein actor_id und thread_id im anzugeben. Die Konfiguration ist unten dargestellt und der Agentenaufruf wird im nächsten Abschnitt gezeigt. Wenn Ihre Anwendung lediglich auf einfache Konversationspersistenz angewiesen ist, können Sie den Abschnitt mit dem Langzeitgedächtnis überspringen.

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

Konfiguration für intelligente Langzeitspeichersuche

Bei Speichern im LangGraph Langzeitgedächtnis haben Sie mehr Flexibilität bei der Verarbeitung von Nachrichten. Wenn sich die Anwendung beispielsweise nur mit Benutzereinstellungen befasst, müssten Sie nur die HumanMessage Objekte in der Konversation speichern. Für Zusammenfassungen ToolMessage wären alle Typen HumanMessageAIMessage, und relevant. Es gibt zahlreiche Möglichkeiten, dies zu tun, aber ein gängiges Implementierungsmuster besteht darin, Hooks vor und nach dem Modell zu verwenden, wie im folgenden Beispiel gezeigt. Zum Abrufen von Erinnerungen können Sie dem Pre-Model-Hook einen store.search(query) Aufruf hinzufügen und ihn an die Nachricht des Benutzers anhängen, sodass der Agent den gesamten Kontext hat. Alternativ könnte dem Agenten ein Tool zur Verfügung gestellt werden, mit dem er bei Bedarf nach Informationen suchen kann. Alle diese Implementierungsmuster werden unterstützt und die Implementierung variiert je nach Anwendung.

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}

Erstellen Sie den Agenten mit Konfigurationen

Initialisieren Sie das LLM und erstellen Sie einen LangGraph Agenten mit einer Speicherkonfiguration.

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

Rufen Sie den Agenten auf

Rufen Sie den Agenten auf.

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

Ressourcen