Streaming d'enregistrements en mémoire

Le streaming d'enregistrements mémoire dans Amazon Bedrock AgentCore Memory fournit des notifications en temps réel lorsque des enregistrements de mémoire sont créés, mis à jour ou supprimés. Au lieu d'interroger les API pour détecter les modifications, vous recevez des événements push vers un flux de données Kinesis de votre compte, ce qui permet aux architectures basées sur les événements de réagir aux modifications du cycle de vie des enregistrements de mémoire au fur et à mesure qu'elles se produisent.

Grâce au streaming d'enregistrements en mémoire, vous pouvez :

Comment ça marche

Le streaming d'enregistrements en mémoire utilise un modèle de diffusion basé sur le push. Lorsque les enregistrements de mémoire sont modifiés, les événements sont automatiquement publiés sur votre Kinesis Data Stream.

Les événements sont déclenchés par les opérations suivantes :

Types d'événements en streaming

Le tableau suivant décrit les types d'événements de flux pris en charge et indique à quel moment ils sont déclenchés.

Schéma d'événement

MemoryRecordCreated / MemoryRecordUpdated

MemoryRecordCreatedet MemoryRecordUpdated les événements partagent le même schéma.

{
  "memoryStreamEvent": {
    "eventType": "<MemoryRecordCreated, MemoryRecordUpdated>",
    "eventTime": "2026-03-06T16:45:00.000Z",
    "memoryId": "<memory-id>",
    "memoryRecordId": "<memory-record-id>",
    "namespaces": ["<namespace>"],
    "createdAt": 1736622300000,
    "memoryStrategyId": "<memory-strategy-id>",
    "memoryStrategyType": "<memory-strategy-type>",
    "metadata": {<metadata>},
    "memoryRecordText": "<memory-record-text>"
  }
}

Le memoryRecordText champ n'est inclus que lorsque le niveau de contenu de la configuration de diffusion du flux est défini surFULL_CONTENT. Voir Configurer le niveau de contenu de l'événement pour plus de détails.

MemoryRecordDeleted

{
  "memoryStreamEvent": {
    "eventType": "MemoryRecordDeleted",
    "eventTime": "2026-02-16T00:13:54.912530116Z",
    "memoryId": "<memory-id>",
    "memoryRecordId": "<memory-record-id>"
  }
}

Les événements de suppression contiennent uniquement les identifiants de mémoire et d'enregistrement, quel que soit le niveau de contenu configuré.

Conditions préalables

Avant de configurer le streaming d'enregistrements en mémoire, vérifiez que vous disposez des éléments suivants :

Configurer le streaming

Étape 1 : Création d’un flux de données Kinesis

Créez un flux de données Kinesis dans votre compte dans lequel Amazon Bedrock AgentCore publiera les événements relatifs au cycle de vie des enregistrements de mémoire.

Vous pouvez créer le flux à l'aide de la AWS console, du CDK ou de la AWS CLI. CloudFormation Si vous activez le chiffrement côté serveur Kinesis, notez l'ARN de la clé KMS : vous en aurez besoin pour les autorisations de rôle IAM.

Étape 2 : configurer un consommateur

Configurez un consommateur pour qu'il traite les événements provenant de votre Kinesis Data Stream.

Accordez à votre consommateur AmazonKinesisReadOnlyAccess (ou des autorisations équivalentes) et ajoutez le Kinesis Data Stream comme déclencheur.

Étape 3 : Création d'un rôle IAM

Créez un rôle IAM qu'Amazon Bedrock AgentCore peut assumer pour publier des événements sur votre Kinesis Data Stream.

Stratégie d'approbation :

{
"Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "bedrock-agentcore.amazonaws.com"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "ArnLike": {
          "aws:SourceArn": "arn:aws:bedrock-agentcore:<region>:<account-id>:memory/*"
        }
      }
    }
  ]
}

Politique d'autorisations :

Pour les stratégies de mémoire intégrées, la politique d'autorisation est la suivante :

{
"Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "kinesis:PutRecords",
        "kinesis:DescribeStream"
      ],
      "Resource": "arn:aws:kinesis:<region>:<account-id>:stream/<stream-name>"
    }
  ]
}

Pour les stratégies de mémoire personnalisées, la politique d'autorisation est la suivante :

{
"Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "kinesis:PutRecords",
        "kinesis:DescribeStream"
      ],
      "Resource": "arn:aws:kinesis:<region>:<account-id>:stream/<stream-name>"
    },
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": [
        "arn:aws:bedrock:*::foundation-model/*",
        "arn:aws:bedrock:*:*:inference-profile/*"
      ],
      "Condition": {
        "StringEquals": {
          "aws:ResourceAccount": "${aws:PrincipalAccount}"
        }
      }
    }
  ]
}

Si votre Kinesis Data Stream utilise le chiffrement côté serveur, ajoutez ce qui suit à la politique d'autorisation :

{
  "Sid": "KMSPermissions",
  "Effect": "Allow",
  "Action": "kms:GenerateDataKey",
  "Resource": "arn:aws:kms:<region>:<account-id>:key/your-kinesis-data-stream-key-id"
}

Étape 4 : créer une mémoire avec le streaming activé

Utilisez l'CreateMemoryAPI pour créer une AgentCore mémoire Amazon Bedrock avec une ressource de diffusion de flux. Vous devez fournir le memoryExecutionRoleArn lorsque vous spécifiez une ressource de diffusion de flux.

aws bedrock-agentcore-control create-memory \
  --name "MyStreamingMemory" \
  --description "Memory with long term memory record streaming enabled" \
  --event-expiry-duration 30 \
  --memory-execution-role-arn "arn:aws:iam::<account-id>:role/AgentCoreMemoryRole" \
  --stream-delivery-resources '{
    "resources": [
      {
        "kinesis": {
          "dataStreamArn": "arn:aws:kinesis:<region>:<account-id>:stream/<stream-name>",
          "contentConfigurations": [
            {
              "type": "MEMORY_RECORDS",
              "level": "FULL_CONTENT"
            }
          ]
        }
      }
    ]
  }'

Étape 5 : Vérifiez votre intégration de streaming

Lorsque vous créez une mémoire avec le streaming activé, Amazon Bedrock AgentCore Memory valide la configuration et les autorisations. Une fois la validation réussie, un StreamingEnabled événement est publié sur votre Kinesis Data Stream.

Vérifiez la présence d'un événement de validation auprès de votre consommateur au format suivant :

{
  "memoryStreamEvent": {
    "eventType": "StreamingEnabled",
    "eventTime": "2026-03-03T19:27:08.344082626Z",
    "memoryId": "<memory-id>",
    "message": "Streaming enabled for memory resource: <memory-id>"
  }
}

Configurer le niveau de contenu de l'événement

Le contentConfigurations champ contrôle les données incluses dans chaque événement. Vous pouvez choisir entre deux niveaux de contenu :

METADATA_ONLYÀ utiliser pour les notifications d'événements légères où il vous suffit de savoir qu'un changement s'est produit. FULL_CONTENTÀ utiliser lorsque votre traitement en aval a besoin du texte d'enregistrement en mémoire sans effectuer d'appels d'API supplémentaires.

Testez votre implémentation

Étape 1 : Création d'événements de test

Utilisez les API Data Plane pour générer des événements liés au cycle de vie des enregistrements de mémoire et vérifier qu'ils apparaissent chez votre consommateur.

Créez des événements via la mémoire à court terme (déclenche une extraction asynchrone) :

aws bedrock-agentcore create-event \
  --memory-id "<memory-id>" \
  --actor-id "test-user" \
  --session-id "test-session-1" \
  --event-timestamp "$(date -u +"%Y-%m-%dT%H:%M:%S.%3NZ")" \
  --payload '[
    {
      "conversational": {
        "content": {"text": "I prefer Italian restaurants with outdoor seating"},
        "role": "USER"
      }
    },
    {
      "conversational": {
        "content": {"text": "Noted! I will remember your preference for Italian restaurants with outdoor seating."},
        "role": "ASSISTANT"
      }
    }
  ]'

Créez des enregistrements directement :

aws bedrock-agentcore batch-create-memory-records \
  --memory-id "<memory-id>" \
  --records '[
    {
      "requestIdentifier": "test-1",
      "content": {"text": "User prefers window seats on flights"},
      "namespaces": ["travel/test-user"],
      "timestamp": "1729525989"
    }
  ]'

Étape 2 : vérifier la livraison

Vérifiez auprès de votre client pour confirmer que les événements sont bien reçus. Vous devriez voir les MemoryRecordCreated événements relatifs aux enregistrements créés par l'une ou l'autre méthode.

Vous pouvez également surveiller l'état des livraisons à l'aide des métriques et des journaux.

Vous pouvez utiliser l'ListMemoryRecordsAPI pour effectuer des références croisées :

aws bedrock-agentcore list-memory-records \
  --memory-id "<memory-id>" \
  --namespace "<namespace>"

Gérer la configuration du streaming

Mettre à jour la configuration du streaming

Utilisez l'UpdateMemoryAPI pour modifier ou supprimer la ressource de diffusion de flux.

Supprimer le streaming :

aws bedrock-agentcore-control update-memory \
  --region us-east-1 \
  --memory-id "<memory-id>" \
  --stream-delivery-resources '{"resources": []}'

Modifier le niveau du contenu

aws bedrock-agentcore-control update-memory \
  --memory-id "<memory-id>" \
  --stream-delivery-resources '{
    "resources": [
      {
        "kinesis": {
          "dataStreamArn": "arn:aws:kinesis:us-east-1:<account-id>:stream/<stream-name>",
          "contentConfigurations": [
            {
              "type": "MEMORY_RECORDS",
              "level": "METADATA_ONLY"
            }
          ]
        }
      }
    ]
  }'

Observabilité

Amazon Bedrock AgentCore Memory envoie des CloudWatch statistiques et des journaux à votre AWS compte, vous donnant ainsi une visibilité sur l'état de santé et l'état de diffusion des flux d'enregistrements en mémoire.

Métriques

Les métriques sont publiées sur votre compte sous l'espace de AWS/Bedrock-AgentCore noms.

Toutes les métriques sont émises sous forme Count d'unités avec les dimensions suivantes :

Journaux

Amazon Bedrock AgentCore Memory envoie des journaux à votre compte en cas de panne de publication (non réessayable) sur le terminal.