Conditions préalables Étape 1 : Création d'un AgentCore souvenir Étape 2 : Écrire les événements dans la 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 AgentCore Memory vous permet de créer et de gérer des ressources de AgentCore mémoire qui stockent le contexte des conversations pour vos agents IA. Ce guide de démarrage vous guide tout au long de l'installation des dépendances et de la mise en œuvre des fonctionnalités de mémoire à court et à long terme. Les instructions utilisent l' AgentCore interface de ligne de commande.

La procédure est la suivante :

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

Pour d'autres exemples, consultez les exemples Exemples d'Amazon Bedrock AgentCore Memory 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 20 installations (pour la AgentCore CLI)

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


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

La AgentCore CLI fournit des commandes permettant de créer et de gérer des ressources mémoire. agentcore add memoryUtilisez-le pour créer une mémoire et agentcore deploy la provisionner AWS. Pour les opérations relatives aux événements et la gestion des sessions, utilisez le SDK AgentCore Python (bedrock-agentcore).

Note

La AgentCore CLI vous aide à créer et à déployer des ressources mémoire. Pour les opérations d'API de service direct, consultez la documentation Boto3 : bedrock-agentcore-control et bedrock-agentcore. https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore.html

Exemple complet : consultez les AgentCore exemples Amazon Bedrock qui illustrent les étapes 1 à 3.

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

Vous avez besoin d'une AgentCore mémoire pour commencer à stocker les informations de 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 extraire des informations et les placer dans des enregistrements de mémoire à long terme, la ressource nécessite une stratégie de mémoire, c'est-à-dire une configuration qui définit 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).

Au cours de 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 AgentCore mémoire dans la AWS console.

Créez de la mémoire grâce à 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 dans la 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. Deuxièmement, des informations pertinentes sont extraites des événements et inscrites dans des enregistrements 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 allez créer trois événements, simulant des messages entre un utilisateur final et un robot de discussion.


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 (tournants) 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 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 de mémoire sémantique à long terme, le système extrait et stocke des informations factuelles.

Vous pouvez répertorier tous les enregistrements de 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 sessions :


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(str(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, avec des traits de soulignement) qui est automatiquement disponible dans l'environnement d'exécution de votre agent après le déploiement.

Nettoyage

Lorsque vous en 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 à votre ressource mémoire.
Activez l'observabilité pour une meilleure visibilité du 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