Voraussetzungen Schritt 1: Erstellen Sie einen Speicher AgentCore Schritt 2: Ereignisse in den Speicher schreiben Schritt 3: Rufen Sie Datensätze aus dem Langzeitgedächtnis ab Speicher zu einem vorhandenen Agenten hinzufügen Bereinigen Nächste Schritte

Erste Schritte mit AgentCore Memory

Amazon Bedrock Mit Amazon Bedrock AgentCore Memory können Sie AgentCore Speicherressourcen erstellen und verwalten, die den Konversationskontext für Ihre KI-Agenten speichern. Diese ersten Schritte führen Sie durch die Installation von Abhängigkeiten und die Implementierung von Kurzzeit- und Langzeitgedächtnisfunktionen. Die Anweisungen verwenden die AgentCore CLI.

Die Schritte sind wie folgt:

Erstellen Sie einen AgentCore Speicher, der eine semantische Strategie enthält
Schreiben Sie Ereignisse (Konversationsverlauf) in die Speicherressource
Rufen Sie Speicherdatensätze aus dem Langzeitgedächtnis ab

Weitere Beispiele finden Sie unter Amazon Bedrock AgentCore Memory-Beispiele.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

AWS Konto mit konfigurierten Anmeldeinformationen (aws configure)
Python 3.10+ installiert
Node.js 18+ installiert (für die AgentCore CLI)

Um mit Amazon Bedrock Amazon Bedrock AgentCore Memory zu beginnen, installieren Sie die Abhängigkeiten, erstellen Sie ein AgentCore CLI-Projekt und richten Sie eine virtuelle Umgebung ein. Die folgenden Befehle können direkt im Terminal ausgeführt werden.


pip install bedrock-agentcore
npm install -g @aws/agentcore
agentcore create --name agentcore-memory-quickstart --no-agent
cd agentcore-memory-quickstart
python -m venv .venv
source .venv/bin/activate

Die AgentCore CLI bietet Befehle zum Erstellen und Verwalten von Speicherressourcen. Wird verwendet, agentcore add memory um einen Speicher agentcore deploy zu erstellen und ihn bereitzustellen AWS. Verwenden Sie für Ereignisoperationen und Sitzungsverwaltung das AWS Python-SDK (Boto3) (bedrock-agentcore).

Anmerkung

Die AgentCore CLI hilft Ihnen bei der Erstellung und Bereitstellung von Speicherressourcen. Den vollständigen Satz der Amazon Bedrock AgentCore Memory-Operationen finden Sie in der Boto3-Dokumentation: bedrock-agentcore-control und bedrock-agentcore.

Vollständiges Beispiel: Sehen Sie sich die Amazon AgentCore Bedrock-Beispiele an, die die Schritte 1—3 demonstrieren.

Schritt 1: Erstellen Sie einen Speicher AgentCore

Sie benötigen einen AgentCore Speicher, um mit dem Speichern von Informationen für Ihren Agenten zu beginnen. Standardmäßig können Speicherereignisse (die wir als Kurzzeitgedächtnis bezeichnen) in einen AgentCore Speicher geschrieben werden. Damit Erkenntnisse extrahiert und in Langzeitgedächtnisaufzeichnungen aufgenommen werden können, benötigt die Ressource eine Speicherstrategie. Dabei handelt es sich um eine Konfiguration, die definiert, wie Konversationsdaten verarbeitet werden sollen und welche Informationen extrahiert werden sollen (wie Fakten, Präferenzen oder Zusammenfassungen).

In diesem Schritt erstellen Sie ein AgentCore Gedächtnis mit einer semantischen Strategie, sodass sowohl das Kurzzeit- als auch das Langzeitgedächtnis genutzt werden können. Das dauert 2-3 Minuten. Sie können AgentCore Speicherressourcen auch in der AWS Konsole erstellen.

Speicher mit semantischer Strategie erstellen:

Beispiel

Stellen Sie nach der Bereitstellung sicher, dass der Speicher erstellt wurde:


agentcore status

Schritt 2: Ereignisse in den Speicher schreiben

Sie können Ereignisse als AgentCore Kurzzeitgedächtnis in ein Gedächtnis schreiben und daraus Erkenntnisse für das Langzeitgedächtnis extrahieren.

Das Schreiben von Ereignissen in den Speicher hat mehrere Zwecke. Erstens werden die Inhalte von Ereignissen (in der Regel der Gesprächsverlauf) im Kurzzeitgedächtnis gespeichert. Zweitens werden relevante Erkenntnisse aus Ereignissen gewonnen und als Teil des Langzeitgedächtnisses in Speicheraufzeichnungen geschrieben.

Die Speicherressourcen-ID, die Akteur-ID und die Sitzungs-ID sind erforderlich, um ein Ereignis zu erstellen. In diesem Schritt erstellen Sie drei Ereignisse, die Nachrichten zwischen einem Endbenutzer und einem Chat-Bot simulieren.


import boto3
from bedrock_agentcore.memory import MemorySessionManager
from bedrock_agentcore.memory.constants import ConversationalMessage, MessageRole

control_client = boto3.client('bedrock-agentcore-control', region_name='us-west-2')

# Retrieve the memory created in Step 1
response = control_client.list_memories()
memory = response['memories'][0]
memory_id = memory['id']

# Create a session to store memory events
session_manager = MemorySessionManager(
    memory_id=memory_id,
    region_name="us-west-2")

session = session_manager.create_memory_session(
    actor_id="User1",
    session_id="OrderSupportSession1"
)

# Write memory events (conversation turns)
session.add_turns(
    messages=[
        ConversationalMessage(
            "Hi, how can I help you today?",
            MessageRole.ASSISTANT)],
)

session.add_turns(
    messages=[
        ConversationalMessage(
            "Hi, I am a new customer. I just made an order, but it hasn't arrived. The Order number is #35476",
            MessageRole.USER)],
)

session.add_turns(
    messages=[
        ConversationalMessage(
            "I'm sorry to hear that. Let me look up your order.",
            MessageRole.ASSISTANT)],
)

Sie können Ereignisse (Runden) für einen bestimmten Schauspieler abrufen, nachdem sie geschrieben wurden.


# Get the last k turns in the session
turns = session.get_last_k_turns(k=5)

for turn in turns:
    print(f"Turn: {turn}")

In diesem Fall können Sie die letzten drei Ereignisse für den Schauspieler und die Session sehen.

Schritt 3: Rufen Sie Datensätze aus dem Langzeitgedächtnis ab

Nachdem die Ereignisse in die Speicherressource geschrieben wurden, wurden sie analysiert und nützliche Informationen wurden an das Langzeitgedächtnis gesendet. Da der Speicher eine semantische Langzeitgedächtnisstrategie enthält, extrahiert und speichert das System Sachinformationen.

Sie können alle Speicherdatensätze auflisten mit:


# List all memory records
memory_records = session.list_long_term_memory_records(
    namespace_path="/"
)

for record in memory_records:
    print(f"Memory record: {record}")
    print("--------------------------------------------------------------------")

Oder fragen Sie im Rahmen einer semantischen Suche nach den relevantesten Informationen:


# Perform a semantic search
memory_records = session.search_long_term_memories(
    query="can you summarize the support issue",
    namespace_path="/",
    top_k=3
)

Wichtige Informationen über den Benutzer werden wahrscheinlich im Langzeitgedächtnis gespeichert. Agenten können anstelle eines vollständigen Konversationsverlaufs das Langzeitgedächtnis verwenden, um sicherzustellen, dass LLMs nicht mit Kontext überlastet werden.

Speicher zu einem vorhandenen Agenten hinzufügen

Wenn Sie einen Strings-Agenten ohne Speicher erstellt haben und ihn später hinzufügen möchten, gehen Sie wie folgt vor:

Fügen Sie Ihrem Projekt eine Speicherressource hinzu:


agentcore add memory --name MyMemory --strategies SEMANTIC,SUMMARIZATION
agentcore deploy

Erstellen Sie das memory/ Verzeichnis in Ihrem Agenten:
```
mkdir -p app/MyAgent/memory
```

Erstellen Sieapp/MyAgent/memory/session.py:


import os
from typing import Optional
from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager

MEMORY_ID = os.getenv("MEMORY_MYMEMORY_ID")
REGION = os.getenv("AWS_REGION")

def get_memory_session_manager(session_id: str, actor_id: str) -> Optional[AgentCoreMemorySessionManager]:
    if not MEMORY_ID:
        return None

    retrieval_config = {
        f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
        f"/summaries/{actor_id}/{session_id}": RetrievalConfig(top_k=3, relevance_score=0.5)
    }

    return AgentCoreMemorySessionManager(
        AgentCoreMemoryConfig(
            memory_id=MEMORY_ID,
            session_id=session_id,
            actor_id=actor_id,
            retrieval_config=retrieval_config,
        ),
        REGION
    )

Aktualisieren Sie Ihrenmain.py, um den Sitzungsmanager zu verwenden:


from memory.session import get_memory_session_manager

@app.entrypoint
async def invoke(payload, context):
    session_id = getattr(context, 'session_id', 'default-session')
    user_id = getattr(context, 'user_id', 'default-user')

    agent = Agent(
        model=load_model(),
        session_manager=get_memory_session_manager(session_id, user_id),
        system_prompt="You are a helpful assistant.",
    )

    response = agent(payload.get("prompt"))
    return response

Stellen Sie das aktualisierte Projekt bereit:
```
agentcore deploy
```

Anmerkung

Jede Speicherressource erhält eine Umgebungsvariable MEMORY_<NAME>_ID (Großbuchstaben, mit Unterstrichen), die nach der Bereitstellung automatisch in der Laufzeitumgebung Ihres Agenten verfügbar ist.

Bereinigen

Wenn Sie mit der Speicherressource fertig sind, können Sie sie löschen:


agentcore remove memory --name CustomerSupportSemantic
agentcore deploy

Nächste Schritte

Berücksichtigen Sie dabei Folgendes:

Fügen Sie Ihrer Speicherressource eine weitere Strategie hinzu.
Aktivieren Sie die Beobachtbarkeit, um einen besseren Einblick in die Funktionsweise des Speichers zu erhalten
Schauen Sie sich weitere Beispiele an.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Vergleichen Sie das Langzeitgedächtnis mit Retrieval-Augmented Generation

Erschaffe eine AgentCore Erinnerung