AWS Builder Center
Memória semântica para agentes de IA com vector search nativo do DynamoDB

Memória semântica para agentes de IA com vector search nativo do DynamoDB

Mostro, na prática, como implementar memória semântica para agentes de IA com vector search nativo do DynamoDB em Rust. O foco está nas decisões que mais impactam custo, confiabilidade e operação em produção.

Software Engineer
Em agosto de 2026 o DynamoDB passou a indexar e buscar vetores de forma nativa. Resolvi testar a novidade construindo algo para usar de verdade: uma camada de memória de longo prazo para agentes de IA, escrita em Rust, que qualquer cliente MCP consegue consultar.
Este artigo está dividido em quatro partes. A primeira explica por que esse recurso muda o desenho de arquitetura de uma aplicação agência com memória. A segunda mostra a modelagem, que é onde mora a decisão mais importante. A terceira trata de três detalhes da API que quebram em silêncio se você não souber que existem. A quarta fecha com o deploy.

Por que isso muda o jogo?

A memória de um agente é um caso de uso que parece pedir um banco vetorial dedicado, mas na prática não é mais necessário.
Pense em coisas que você pode guardar guarda: "o Rafael prefere café coado", "a decisão de usar Graviton foi tomada em julho", "o deploy de sexta quebrou o billing". Cada um desses registros é operacional. Tem dono, tem data, tem sessão de origem, precisa expirar em algum momento, e alguém eventualmente vai querer apagar.
Antes do vector search nativo, o desenho de arquitetura padrão era gravar o registro no DynamoDB, ligar o Streams, disparar uma Lambda e replicar o embedding para um banco vetorial externo. Isso é escrita dupla. Você passa a conviver com divergência entre os dois ambientes, com backfill quando o pipeline cai, e com a dúvida permanente sobre qual dos dois tem a fonte da verdade.
Com o índice vetorial nativo, um  PutItem  grava o item e indexa o vetor na mesma operação. A  documentação do recurso  é direta ao dizer que o objetivo é eliminar pipelines de replicação entre o DynamoDB e um vector store separado.

Três outros pontos me convenceram:

  • O TTL continua funcionando. Quando o TTL apaga um item expirado, a entrada correspondente some do índice vetorial também. Para memória de agente isso é exatamente o que você quer, porque esquecer é requisito, não bug. Não precisa de job de compactação em sistema paralelo.
  • A latência entra no caminho crítico. O  recall  roda a cada turno da conversa, antes do LLM responder. Uma dependência a menos e um salto de rede a menos fazem diferença no p99.
  • E o operacional é zero. Capacidade on-demand, sem cluster, sem tuning de HNSW ou IVF. Combina com Lambda, que também não tem servidor para gerenciar.

A arquitetura final ficou assim:



Escolher modelagem corretamente define escala e custo

O índice vetorial aceita um  SearchSchema , que define uma partition key e atributos de filtro. Essa é a parte da arquitetura que mais impacta a conta no fim do mês, e é fácil deixar passar despercebido.
A tabela ficou com  user_id  como partition key e  memory_id  como sort key. O índice vetorial usa o mesmo  user_id  como HASH:
{
"IndexName": "MemoryIndex",
"VectorAttribute": { "AttributeName": "embedding" },
"SearchSchema": [
{ "AttributeName": "user_id", "SearchSchemaElementType": "HASH" },
{ "AttributeName": "kind", "SearchSchemaElementType": "INLINE_FILTER" }
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": ["text", "created_at", "source"]
},
"Dimensions": 1024,
"DistanceFunction": "COSINE"
}
Repetir o  user_id  nos dois lugares resolve quatro problemas de uma vez.
  • Custo. A busca vetorial é cobrada por dado processado. Com a partition key, cada  SearchVectors  varre as memórias de um usuário. Sem ela, o DynamoDB irá varrer o índice inteiro. Com dez mil usuários a diferença é de ordens de grandeza para a mesma query, e ela cresce conforme a base aumenta.
  • Escala. As cotas de throughput do índice vetorial são por valor de partition key:  1 GBps de busca e 10 MBps de escrita . Ou seja, capacidade cresce com o número de usuários em vez de ser dividida entre eles.
  • Latência. Menos dado examinado, resposta mais rápida.
  • Correção. A documentação avisa que um item gravado sem o atributo de partition key do índice é aceito na tabela base e silenciosamente excluído do índice. Como aqui esse atributo é a própria chave primária da tabela, esse modo de falha simplesmente não existe.
A própria AWS deixa claro que escopo por partition key é otimização de localidade, e não fronteira de segurança: quem tem  dynamodb:SearchVectors  no índice consegue buscar qualquer valor de partition key, e condition keys de  FGAC  como  dynamodb:LeadingKeys  não se aplicam a essa API. Isolamento forte exige tabelas separadas.
Sobre a projeção: usei  INCLUDE  em vez de  ALL  de propósito. O  SearchVectors  só devolve atributo projetado, e o vetor fica de fora por padrão. Trazer 1024 floats de volta a cada resultado inflaria a resposta e os bytes cobrados sem nenhum ganho.

Três detalhes que falham em silêncio

Aqui está o que eu gostaria de ter lido antes de começar. Nenhum dos três dá erro de compilação, e dois deles falham calados.

1. O vetor tem duas formas diferentes

Quando você armazena um vetor num item, ele é uma lista do DynamoDB:
{ "embedding": { "L": [ { "N": "0.1" }, { "N": "-0.5" } ] } }
Quando você passa um vetor de consulta para o  SearchVectors , é uma lista plana, sem o wrapper  L :
[ { "N": "0.1" }, { "N": "-0.5" } ]
A  documentação chama atenção para isso  num aviso destacado, e não é à toa. No Rust as duas conversões ficaram lado a lado no mesmo módulo, para a diferença ser visível numa tela só:
/// Vetor ARMAZENADO no item: lista (L) de números (N).
pub fn to_item_attr(embedding: &Embedding) -> AttributeValue {
AttributeValue::L(embedding.as_slice().iter().map(number).collect())
}

/// Vetor de CONSULTA: lista plana, sem o wrapper L.
pub fn to_query_vector(embedding: &Embedding) -> Vec<AttributeValue> {
embedding.as_slice().iter().map(number).collect()
}

2. Em COSINE, score menor é mais parecido

A API devolve um campo chamado  Score , e a palavra convida você a ordenar decrescente. Num índice  COSINE  isso está invertido: 0 significa mesma direção e 2 significa direção oposta.
Vetor armazenado
Query  [1,0,0,0] 
Score COSINE
 [1, 0, 0, 0] 
idêntico
0.0
 [0.7071, 0.7071, 0, 0] 
45 graus
0.29
 [-1, 0, 0, 0] 
oposto
2.0
Em vez de apenas documentar e torcer pelo uso correto, criei um tipo  Distance  cuja ordenação é naturalmente crescente. Com isso, o ranking virou uma ordenação comum e o corte de relevância tornou-se uma simples validação  distance <= max  o que torna erros de tipo impossíveis de acontecer. Além disso, centralizei toda a conversão de scores da AWS em um único ponto do sistema.

3.  search_vector()  anexa um elemento por chamada

No SDK do Rust, o método no singular adiciona um número ao vetor de busca. Para mandar 1024 dimensões você precisa do setter da lista completa:
let output = client
.search_vectors()
.table_name(&table)
.index_name(&index)
// .search_vector(v) anexaria um elemento por vez
.set_search_vector(Some(to_query_vector(&embedding)))
.top_k(5)
.search_condition_expression("user_id = :uid AND kind = :kind")
.expression_attribute_values(":uid", AttributeValue::S(user_id))
.expression_attribute_values(":kind", AttributeValue::S("preference".into()))
.send()
.await?;
Repare no  search_condition_expression . Se o índice define uma partition key no  SearchSchema , informar o valor dela é obrigatório em toda busca. O inline filter, por sua vez, é opcional. E os operadores disponíveis hoje são só de igualdade: comparação, range e  IN  ainda não existem nessa expressão.
Não use  aws dynamodb wait table-exists  para esperar o índice. Esse waiter libera quando o  TableStatus  ficando  ACTIVE , e nesse momento o índice ainda pode estar em  CREATING .
Pior, um índice adicionado a uma tabela existente reporta  ACTIVE  antes de terminar o backfill, e buscar durante o backfill retornando erro. As duas condições precisam valer, e não existe waiter da AWS para isso:
IndexStatus == ACTIVE && Backfilling != true
No SDK do Rust,  aws-sdk-dynamodb  a partir da versão 1.120.0. Abaixo disso a operação  SearchVectors  simplesmente não existe.

Deploy

Aqui vai o aviso mais prático do artigo. Até o momento em que escrevo, não existe caminho declarativo para criar um índice vetorial. Verifiquei os três:
Caminho
Suporte
 hashicorp/aws  6.58, recurso  aws_dynamodb_table 
nenhum
CloudFormation  AWS::DynamoDB::Table 
sem a propriedade  VectorIndexes 
 awscc_dynamodb_table  1.96
nenhum, é gerado do schema do CloudFormation
A solução foi manter tudo que é declarativo (tabela, TTL, PITR, API, Lambda, IAM, log groups) e isolar só o índice num  terraform_data  com um script, para poder apagar esse bloco inteiro quando o provider alcançar o recurso.
Isso força dois detalhes. O atributo  kind , usado apenas pelo inline filter, não pode ser declarado no  aws_dynamodb_table : o provider valida que todo atributo declarado seja usado por alguma chave ou índice, falha o plan com "all attributes must be indexed", e ele não enxerga índices vetoriais. O script registra o atributo via  UpdateTable . Consequentemente, o recurso precisa de  lifecycle { ignore_changes = [attribute] } , senão o plan seguinte tentaria remover o atributo que o script acabou de adicionar.

Impacto de Rede do SearchVectors no DynamoDB: Endpoints Dedicados e Limitações de VPC

O recurso de busca vetorial (SearchVectors) resolve para um endpoint dedicado, search-dynamodb.<region>.amazonaws.com, que opera separadamente do endpoint tradicional do DynamoDB.
Essa arquitetura gera três consequências práticas fundamentais:
  • Incompatibilidade com o DynamoDB Local: O ambiente local não oferece suporte a essas rotas. Tentar sobrescrever a propriedade endpoint_url acaba quebrando o roteamento da busca em vez de direcioná-la corretamente.
  • Exigência de saída na VPC: Dentro de uma VPC, esse host demanda conectividade de saída própria. O sintoma de omitir essa configuração é crítico e sutil: as operações de escrita continuam funcionando perfeitamente, mas as buscas falham.
  • Ausência de vpc_config na Lambda: Para simplificar a arquitetura e evitar falhas de conectividade de rede neste projeto, a função Lambda foi mantida propositalmente sem a configuração de vpc_config.

Porque Rust

A decisão de adotar Rust em arquiteturas serverless se resume à eficiência operacional e segurança que a linguagem entrega nativamente. Se você busca previsibilidade e redução de custos na nuvem, basta observar o comportamento exato do código em produção.
Analisando os logs reais de execução da função AWS Lambda, estes são os resultados obtidos:
  • Uso de Memória: 31 MB a 33 MB
  • Tempo de Execução (Warm Start): ~6 ms a 27 ms
  • Tempo de Inicialização (Cold Start): ~94 ms a 119 ms
Na prática, o que esses números significam para o seu projeto:
  1. Custo Otimizado ao Extremo O consumo de memória fixado na casa dos 31 MB permite que a função seja provisionada na configuração mais barata da infraestrutura (128 MB), garantindo sobra de recursos e o menor valor de cobrança possível por milissegundo executado.
  1. Baixíssima Latência Com execuções processadas em cerca de 6 milissegundos e tempos de inicialização restritos a 100 milissegundos, não existe impacto perceptível de infraestrutura para quem consome a aplicação. O sistema responde em tempo real.
  1. Escala Estável e Previsível Por ser uma linguagem compilada e sem as interrupções de um Garbage Collector, o tempo de resposta se mantém estável. A aplicação entrega a mesma velocidade tanto em períodos de baixo tráfego quanto durante picos severos de acesso.

Conclusão

O que mais me surpreendeu não foi o vector search em si, que funciona bem e é simples de usar. Foi quanto do resultado final depende de escolhas tomadas antes da primeira linha de código: a partition key do índice define o custo, o formato de payload do API Gateway define se dá para saber quem chamou, e o endpoint separado define se você consegue testar localmente.
Se for testar, comece pelo  tutorial oficial , que sobe um catálogo de 50 produtos e faz uma busca semântica em poucos comandos. Lembre de derrubar os recursos depois, porque o storage do índice é cobrado enquanto ele existir, com buscas ou sem elas.
O projeto completo está no  GitHub .

Referências

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article