Conditions préalables Étape 1 : Création d'un AgentCore souvenir Étape 2 : Écrire les événements en mémoire Étape 3 : récupérer des enregistrements de la mémoire à long terme Ajouter de la mémoire à un agent existant Nettoyage Étapes suivantes

Commencez avec AgentCore Memory

Amazon Bedrock Amazon Bedrock AgentCore Memory vous permet de créer et de gérer des ressources de AgentCore mémoire qui stockent le contexte de conversation pour vos agents IA. Ce guide de démarrage vous explique comment installer les dépendances et implémenter les fonctionnalités de mémoire à court et à long terme. Les instructions utilisent la AgentCore CLI.

La procédure est la suivante :

Créez une AgentCore mémoire contenant une stratégie sémantique
Écrire des événements (historique des conversations) dans la ressource mémoire
Récupérez des enregistrements de mémoire à partir de la mémoire à long terme

Pour d'autres exemples, consultez les exemples d'Amazon Bedrock AgentCore Memory.

Conditions préalables

Avant de commencer, assurez-vous d'avoir :

AWS Compte avec informations d'identification configurées (aws configure)
Python 3.10+ installé
Node.js Plus de 18 personnes installées (pour la AgentCore CLI)

Pour commencer à utiliser Amazon Bedrock Amazon Bedrock AgentCore Memory, installez les dépendances, créez un projet AgentCore CLI et configurez un environnement virtuel. Les commandes ci-dessous peuvent être exécutées directement dans le terminal.


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

La AgentCore CLI fournit des commandes pour créer et gérer des ressources de mémoire. agentcore add memoryÀ utiliser pour créer une mémoire et agentcore deploy l'approvisionner AWS. Pour les opérations d'événements et la gestion des sessions, utilisez le SDK AWS Python (Boto3) (). bedrock-agentcore

Note

La AgentCore CLI vous aide à créer et à déployer des ressources de mémoire. Pour l'ensemble complet des opérations Amazon Bedrock AgentCore Memory, consultez la documentation Boto3 : bedrock-agentcore-control et bedrock-agentcore.

Exemple complet : consultez les exemples d'Amazon Bedrock AgentCore illustrant les étapes 1 à 3.

Étape 1 : Création d'un AgentCore souvenir

Vous avez besoin d'une AgentCore mémoire pour commencer à stocker des informations pour votre agent. Par défaut, les événements de mémoire (que nous appelons mémoire à court terme) peuvent être écrits dans une AgentCore mémoire. Pour que les informations soient extraites et placées dans des enregistrements de mémoire à long terme, la ressource nécessite une stratégie de mémoire, c'est-à-dire une configuration définissant la manière dont les données conversationnelles doivent être traitées et les informations à extraire (telles que des faits, des préférences ou des résumés).

Dans cette étape, vous créez une AgentCore mémoire avec une stratégie sémantique afin que la mémoire à court et à long terme puisse être utilisée. Cela prendra 2 à 3 minutes. Vous pouvez également créer des ressources de AgentCore mémoire dans la AWS console.

Créez de la mémoire avec une stratégie sémantique :

Exemple

Après le déploiement, vérifiez que la mémoire a été créée :


agentcore status

Étape 2 : Écrire les événements en mémoire

Vous pouvez écrire des événements dans une AgentCore mémoire sous forme de mémoire à court terme et en extraire des informations pour la mémoire à long terme.

L'écriture d'événements dans la mémoire a plusieurs objectifs. Tout d'abord, le contenu des événements (le plus souvent l'historique des conversations) est stocké sous forme de mémoire à court terme. Ensuite, des informations pertinentes sont extraites des événements et enregistrées dans des dossiers de mémoire dans le cadre de la mémoire à long terme.

L'identifiant de ressource mémoire, l'identifiant d'acteur et l'identifiant de session sont requis pour créer un événement. Au cours de cette étape, vous créez trois événements simulant des messages entre un utilisateur final et un chatbot.


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)],
)

Vous pouvez obtenir des événements (tours) pour un acteur spécifique une fois qu'ils ont été écrits.


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

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

Dans ce cas, vous pouvez voir les trois derniers événements pour l'acteur et pour la session.

Étape 3 : récupérer des enregistrements de la mémoire à long terme

Une fois les événements écrits dans la ressource mémoire, ils ont été analysés et des informations utiles ont été envoyées à la mémoire à long terme. Comme la mémoire contient une stratégie sémantique de mémoire à long terme, le système extrait et stocke des informations factuelles.

Vous pouvez répertorier tous les enregistrements en mémoire avec :


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

Ou demandez les informations les plus pertinentes dans le cadre d'une recherche sémantique :


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

Les informations importantes concernant l'utilisateur sont probablement stockées dans la mémoire à long terme. Les agents peuvent utiliser la mémoire à long terme plutôt que l'historique complet des conversations pour s'assurer que les LLM ne sont pas surchargés de contexte.

Ajouter de la mémoire à un agent existant

Si vous avez créé un agent Strands sans mémoire et que vous souhaitez l'ajouter ultérieurement, procédez comme suit :

Ajoutez une ressource mémoire à votre projet :


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

Créez le memory/ répertoire dans votre agent :
```
mkdir -p app/MyAgent/memory
```

Créez 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
    )

Mettez à jour votre main.py compte pour utiliser le gestionnaire de session :


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

Déployez le projet mis à jour :
```
agentcore deploy
```

Note

Chaque ressource mémoire reçoit une variable d'environnement MEMORY_<NAME>_ID (majuscules, soulignées) qui est automatiquement disponible dans l'environnement d'exécution de votre agent après le déploiement.

Nettoyage

Lorsque vous avez terminé avec la ressource mémoire, vous pouvez la supprimer :


agentcore remove memory --name CustomerSupportSemantic
agentcore deploy

Étapes suivantes

Éléments à prendre en compte :

Ajoutez une autre stratégie à vos ressources de mémoire.
Activez l'observabilité pour une meilleure visibilité sur le fonctionnement de la mémoire
Regardez d'autres exemples.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Comparez la mémoire à long terme avec Retrieval-Augmented Generation

Créez un AgentCore souvenir