# Self-managed estratégia
<a name="memory-self-managed-strategies"></a>

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](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_BatchCreateMemoryRecords.html),, [BatchDeleteMemoryRecords](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_BatchDeleteMemoryRecords.html)) [BatchUpdateMemoryRecords](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_BatchUpdateMemoryRecords.html), 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:
+ Controle a invocação do pipeline por meio de acionadores configuráveis
+ Integre com sistemas de processamento externos
+ Implemente algoritmos personalizados de extração e consolidação
+ Invoque qualquer modelo preferido para extração e consolidação
+ Defina esquemas de registro de memória personalizados, namespaces e assim por diante.
+ Ingira registros extraídos na memória de longo prazo do Amazon Bedrock AgentCore 

**Topics**
+ [Crie e use uma estratégia autogerenciada](#use-self-managed-strategy)
+ [Pré-requisitos](#prerequisites)
+ [Configurar a infraestrutura](#setting-up-infrastructure)
+ [Crie uma estratégia autogerenciada](#creating-self-managed-strategy)
+ [Entendendo a entrega de carga útil](#understanding-payload-delivery)
+ [Crie seu funil personalizado](#building-custom-pipeline)
+ [Teste sua implementação](#testing-implementation)
+ [Práticas recomendadas](#best-practices)

## Crie e use uma estratégia autogerenciada
<a name="use-self-managed-strategy"></a>

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.

1.  **Configure gatilhos**: defina condições de gatilho (contagem de mensagens, tempo limite de inatividade, contagem de tokens) que invocam seu pipeline com base em eventos de memória de curto prazo

1.  **Receba notificações e entrega de carga útil**: o Amazon Bedrock AgentCore publica notificações para seu tópico do SNS e entrega dados de conversas para seu bucket do S3 quando as condições de gatilho são atendidas

1.  **Extraia registros de memória**: seu pipeline personalizado recupera a carga útil e aplica a lógica de extração para identificar memórias relevantes

1.  **Consolide registros de memória**: processe as memórias extraídas para remover duplicatas e resolver conflitos com registros existentes

1.  **Armazene registros de memória**: use APIs em lote para armazenar registros de memória processados na memória de longo prazo do Amazon Bedrock AgentCore 

## Pré-requisitos
<a name="prerequisites"></a>

Antes de configurar estratégias autogerenciadas, verifique se você tem:
+ Uma AWS conta com as permissões apropriadas
+ Acesso ao Amazon Bedrock AgentCore 
+ Compreensão básica do AWS IAM, Amazon S3 e Amazon SNS

## Configurar a infraestrutura
<a name="setting-up-infrastructure"></a>

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
<a name="create-s3-bucket"></a>

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

**Importante**  
Configure uma política de ciclo de vida para excluir objetos automaticamente após o processamento para controlar os custos.

### Etapa 2: criar um tópico do SNS
<a name="create-sns-topic"></a>

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
<a name="create-iam-role"></a>

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
<a name="creating-self-managed-strategy"></a>

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
<a name="required-permissions"></a>

Seu usuário ou função do IAM precisa:
+ bedrock-agentcore: \* permissões
+  `iam:PassRole`permissão para a função de execução

### Crie uma AgentCore memória com uma estratégia autogerenciada
<a name="create-memory-with-strategy"></a>

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
<a name="understanding-payload-delivery"></a>

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
<a name="sns-notification-message"></a>

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

### Estrutura de carga útil S3
<a name="s3-payload-structure"></a>

```
{
  "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
<a name="building-custom-pipeline"></a>

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
<a name="set-up-compute"></a>

1. Crie uma fila SQS e inscreva-a em seu tópico do SNS

1. Crie uma função AWS Lambda para processar notificações

1. Configurar as permissões do perfil de execução do Lambda

### Etapa 2: Processar o pipeline
<a name="processing-pipeline"></a>

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

1. Manipulação de notificações - Processamento de notificações do SNS e download de cargas do S3

1. Extração de memória - Usando modelos básicos para extrair informações relevantes das conversas

1. Consolidação de memória - desduplicação e fusão de memórias extraídas com registros existentes

1. Ingestão em lote - Armazenando memórias processadas de volta no Amazon Bedrock AgentCore usando APIs em lote

## Teste sua implementação
<a name="testing-implementation"></a>

1.  **Crie eventos**: use as AgentCore APIs do Amazon Bedrock para criar eventos de conversação () `CreateEvent`

1.  **Monitore notificações**: verifique se o tópico do SNS recebe notificações quando os gatilhos são atendidos

1.  **Valide o processamento**: verifique se sua função Lambda processa cargas corretamente e extrai registros de memória

1.  **Verifique a ingestão**: use `list-memory-records` para confirmar se as memórias extraídas estão armazenadas

### Exemplo: criação de eventos de teste
<a name="creating-test-events"></a>

```
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
<a name="retrieving-memory-records"></a>

```
# 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
<a name="best-practices"></a>

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

### Desempenho e confiabilidade
<a name="performance-reliability"></a>
+  **Compartilhamento de SLA**: o SLA de geração de registros de Long-term memória é compartilhado entre o Amazon Bedrock AgentCore e seu pipeline autogerenciado
+  **Tratamento de erros**: implemente a lógica de repetição adequada e as filas de letras mortas para falhas no processamento
+  **Monitoramento**: configure CloudWatch registros, métricas, alarmes para falhas e latência de depuração e processamento. Além disso, verifique os registros vendidos do Amazon Bedrock em AgentCore busca de falhas na entrega da carga útil

### Otimização de custos
<a name="cost-optimization"></a>
+  **Políticas de ciclo de vida do S3**: configure a exclusão automática de cargas processadas para controlar os custos de armazenamento
+  **Right-sizing**: escolha as configurações apropriadas de memória e tempo limite de computação com base em seus requisitos de processamento

### Considerações sobre o processamento
<a name="processing-considerations"></a>
+  **Otimização do gatilho**: configure as condições do gatilho com base nos requisitos do seu caso de uso - equilibre a eficiência do processamento e a atualização da memória considerando a tolerância do seu aplicativo à latência versus os custos de processamento.
+  **Tópicos do FIFO: use tópicos** do FIFO SNS quando a ordenação da sessão for essencial (por exemplo, para fluxos de trabalho de resumo)
+  **Consolidação de memória**: implemente a lógica de desduplicação para evitar o armazenamento de registros de memória redundantes ou conflitantes, o que reduz os custos de armazenamento e melhora a precisão da recuperação
+  **Organização do registro de memória**: sempre inclua namespaces e IDs de estratégia significativos ao ingerir registros para permitir a categorização, filtragem e recuperação eficientes dos registros de memória

### Segurança
<a name="security"></a>
+  **Privilégio mínimo**: conceda permissões mínimas necessárias para todas as funções do IAM
+  **Criptografia**: use a criptografia KMS para buckets do S3 e tópicos do SNS contendo dados confidenciais