# 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:
1. Erstellen Sie einen AgentCore Speicher, der eine semantische Strategie enthält
1. Schreiben Sie Ereignisse (Konversationsverlauf) in die Speicherressource
1. Rufen Sie Speicherdatensätze aus dem Langzeitgedächtnis ab
Weitere Beispiele finden Sie unter [Amazon Bedrock AgentCore Memory-Beispiele](memory-examples.md).
## 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](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore-control.html).](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore.html)
**Vollständiges Beispiel:** Sehen Sie sich die [Amazon AgentCore Bedrock-Beispiele](https://github.com/awslabs/amazon-bedrock-agentcore-samples/tree/main/01-tutorials) 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:
**Example**
1.
```
agentcore add memory --name CustomerSupportSemantic --strategies SEMANTIC
agentcore deploy
```
1. Führen Sie den Befehl aus, `agentcore` um die TUI zu öffnen, wählen Sie dann **Hinzufügen** und dann **Speicher**:
1. Geben Sie den Speichernamen ein:
1. Wählen Sie die **Semantische** Strategie aus und bestätigen Sie dann:
Führen Sie dann `agentcore deploy` den Befehl aus, um den Speicher bereitzustellen. AWS
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:
1. Fügen Sie Ihrem Projekt eine Speicherressource hinzu:
```
agentcore add memory --name MyMemory --strategies SEMANTIC,SUMMARIZATION
agentcore deploy
```
1. Erstellen Sie das `memory/` Verzeichnis in Ihrem Agenten:
```
mkdir -p app/MyAgent/memory
```
1. Erstellen Sie`app/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
)
```
1. Aktualisieren Sie Ihren`main.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
```
1. Stellen Sie das aktualisierte Projekt bereit:
```
agentcore deploy
```
**Anmerkung**
Jede Speicherressource erhält eine Umgebungsvariable `MEMORY__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](long-term-enabling-long-term-memory.md#long-term-adding-strategies-to-existing-memory) hinzu.
+ [Aktivieren Sie die Beobachtbarkeit,](memory-observability.md) um einen besseren Einblick in die Funktionsweise des Speichers zu erhalten
+ Schauen Sie sich weitere [Beispiele](memory-examples.md) an.