Self-managed estratégia

Uma estratégia autogerenciada na Amazon Bedrock AgentCore Memory oferece controle total sobre seus pipelines de extração e consolidação de memória. Com uma estratégia autogerenciada, você pode criar fluxos de trabalho personalizados de processamento de memória enquanto aproveita o Amazon AgentCore Bedrock para armazenamento e recuperação.

Uma estratégia autogerenciada, combinada com as operações em lote (BatchCreateMemoryRecords,, BatchDeleteMemoryRecords) BatchUpdateMemoryRecords, permite que você ingira diretamente esses registros extraídos na AgentCore memória do Amazon Bedrock para recursos de pesquisa.

Com estratégias autogerenciadas, você pode:

Crie e use uma estratégia autogerenciada

Self-managed as estratégias seguem um processo de cinco etapas, desde a configuração do gatilho até o armazenamento de registros de memória.

Pré-requisitos

Antes de configurar estratégias autogerenciadas, verifique se você tem:

Configurar a infraestrutura

Crie os AWS recursos necessários, incluindo bucket do S3, tópico do SNS e função do IAM, que o Amazon Bedrock AgentCore precisa para acessar seus recursos.

Etapa 1: criar um bucket do S3

Crie um bucket S3 em sua conta onde o Amazon Bedrock AgentCore entregará cargas de eventos em lote.

Etapa 2: criar um tópico do SNS

Crie um tópico do SNS para notificações de trabalho. Use tópicos do FIFO se o processamento do pedido dentro das sessões for importante para seu caso de uso.

Etapa 3: criar um perfil do IAM

Crie uma função do IAM que o Amazon Bedrock AgentCore possa assumir para acessar seus recursos.

Política de confiança

Use a seguinte política de confiança:

{
    "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/*"
                }
            }
        }
    ]
}

Política de permissões

Use a seguinte política de permissões:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3PayloadDelivery",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:PutObject"
            ],
            "Resource": [
                "arn:aws:s3:::your-agentcore-payloads-bucket",
                "arn:aws:s3:::your-agentcore-payloads-bucket/*"
            ]
        },
        {
            "Sid": "SNSNotifications",
            "Effect": "Allow",
            "Action": [
                "sns:GetTopicAttributes",
                "sns:Publish"
            ],
            "Resource": "arn:aws:sns:us-east-1:123456789012:agentcore-memory-jobs"
        }
    ]
}

Permissões adicionais do KMS (se estiver usando recursos criptografados)

Se você usa recursos criptografados, adicione as seguintes permissões do KMS:

{
    "Sid": "KMSPermissions",
    "Effect": "Allow",
    "Action": [
        "kms:GenerateDataKey",
        "kms:Decrypt"
    ],
    "Resource": "arn:aws:kms:us-east-1:123456789012:key/your-key-id"
}

Crie uma estratégia autogerenciada

Use as APIs do plano AgentCore de controle do Amazon Bedrock para criar ou atualizar uma AgentCore memória com estratégias autogerenciadas.

Permissões obrigatórias

Seu usuário ou função do IAM precisa:

Crie uma AgentCore memória com uma estratégia autogerenciada

Use a CreateMemory operação do AWS SDK para criar uma AgentCore memória que tenha uma estratégia autogerenciada.

aws bedrock-agentcore-control create-memory \
  --name "MyCustomMemory" \
  --description "Memory with self-managed extraction strategy" \
  --memory-execution-role-arn "arn:aws:iam::123456789012:role/AgentCoreMemoryRole" \
  --event-expiry-duration 90 \
  --memory-strategies '[
    {
      "customMemoryStrategy": {
        "name": "SelfManagedExtraction",
        "description": "Custom extraction strategy",
        "configuration": {
          "selfManagedConfiguration": {
            "triggerConditions": [
              {
                "messageBasedTrigger": {
                  "messageCount": 6
                }
              },
              {
                "tokenBasedTrigger": {
                  "tokenCount": 1000
                }
              },
              {
                "timeBasedTrigger": {
                  "idleSessionTimeout": 30
                }
              }
            ],
            "historicalContextWindowSize": 2,
            "invocationConfiguration": {
              "payloadDeliveryBucketName": "your-agentcore-payloads-bucket",
              "topicArn": "arn:aws:sns:us-east-1:123456789012:agentcore-memory-jobs"
            }
          }
        }
      }
    }
  ]'

Entendendo a entrega de carga útil

Quando as condições de gatilho são atendidas, o Amazon Bedrock AgentCore envia notificações e cargas usando esquemas específicos.

Mensagem de notificação do SNS

{
  "jobId": "unique-job-identifier",
  "s3PayloadLocation": "s3://bucket/path/to/payload.json",
  "memoryId": "your-memory-id",
  "strategyId": "your-strategy-id"
}

Estrutura de carga útil S3

{
  "requestId": "request-identifier",
  "accountId": "123456789012",
  "memoryId": "your-memory-id",
  "actorId": "user-or-agent-id",
  "sessionId": "conversation-session-id",
  "strategyId": "your-strategy-id",
  "startingTimestamp": 1634567890,
  "endingTimestamp": 1634567920,
  "currentContext": [
    {
      "role": "USER",
      "content": {
        "text": "User message content"
      }
    },
    {
      "role": "ASSISTANT",
      "content": {
        "text": "Assistant response"
      }
    }
  ],
  "historicalContext": [
    {
      "role": "USER",
      "content": {
        "text": "User message content"
      }
    },
    {
      "role": "ASSISTANT",
      "content": {
        "text": "Previous assistant response"
      }
    },
    {
      "blob": "{}",
    }
  ]
}

Crie seu funil personalizado

Esta seção demonstra uma abordagem para criar um pipeline de processamento de memória autogerenciado usando AWS Lambda e SQS. Esse é apenas um exemplo: você pode implementar seu pipeline usando qualquer plataforma de computação (EC2, ECS, Fargate), lógica e estrutura de processamento que atenda às suas necessidades.

Etapa 1: configurar a computação

Etapa 2: Processar o pipeline

O exemplo de pipeline a seguir consiste em quatro componentes principais:

Teste sua implementação

Exemplo: criação de eventos de teste

aws bedrock-agentcore create-event \
  --memory-id "your-memory-id" \
  --actor-id "test-user" \
  --session-id "test-session-1" \
  --event-timestamp "2024-01-15T10:00:00Z" \
  --payload '[{
    "conversational": {
      "content": {"text": "I prefer Italian restaurants with outdoor seating"},
      "role": "USER"
    }
  }]'

Exemplo: Recuperação de registros de memória

# List records belonging to a specific namespace
aws bedrock-agentcore list-memory-records \
  --memory-id "your-memory-id" \
  --namespace "/actor/Jane/" # lists all records present in the given namespace

# List records belonging to a particular namespace hierarchy
aws bedrock-agentcore list-memory-records \
  --memory-id "your-memory-id" \
  --namespace-path "/" # lists all records present under the namespace hierarchy

Práticas recomendadas

Siga essas melhores práticas para desempenho, confiabilidade, otimização de custos e segurança ao implementar estratégias autogerenciadas.

Desempenho e confiabilidade

Otimização de custos

Considerações sobre o processamento

Segurança