As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Self-managed estratégia

Uma estratégia autogerenciada no 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 Bedrock AgentCore para armazenamento e recuperação.

Uma estratégia autogerenciada em combinação com as operações em lote (BatchCreateMemoryRecords, BatchUpdateMemoryRecords, BatchDeleteMemoryRecords) 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 na 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 do 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 vagas. Use tópicos FIFO se a ordem de processamento nas 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 de 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 AWS SDK para criar 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 acionamento 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 o AWS Lambda e o SQS. Esse é apenas um exemplo: você pode implementar seu pipeline usando qualquer plataforma de computação (EC2, ECS, Fargate), estrutura lógica e de processamento que atenda aos seus requisitos.

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 de desempenho, confiabilidade, otimização de custos e segurança ao implementar estratégias autogerenciadas.

Desempenho e confiabilidade

Otimização de custos

Considerações de processamento

Segurança