AWS Builder Center
Arquitetura RAG Serverless: Isolamento Semântico com Amazon Bedrock e Aurora Serverless v2

Arquitetura RAG Serverless: Isolamento Semântico com Amazon Bedrock e Aurora Serverless v2

O artigo disseca a orquestração de bancos de dados vetoriais utilizando a extensão pgvector no Amazon Aurora PostgreSQL e a execução de inferências semânticas apátridas com o Amazon Bedrock. Direcionado a arquitetos de soluções, o material instrumenta a construção de motores de Inteligência Artificial corporativos imunes a alucinações, com respostas ancoradas estritamente em repositórios privados, garantindo latência ultrabaixa via streaming de resposta (Response Streaming) em funções AWS Lambda.

Systems Architect na NTT DATA, Estudante Doutorado na MUST University, 12x AWS e ASD & ADHD
Modelos fundacionais de linguagem (LLMs) sofrem de alucinações críticas quando questionados sobre dados corporativos privados não presentes em seu corpus de treinamento original. A tentativa de mitigar essa deficiência através do ajuste fino (fine-tuning) consome orçamentos massivos de infraestrutura e resulta em modelos estáticos, incapazes de refletir o estado do banco de dados em tempo real. Implementar o padrão Retrieval-Augmented Generation (RAG) utilizando o Amazon Bedrock e o Amazon Aurora PostgreSQL elimina essa barreira. Ao delegar a inferência de linguagem ao Bedrock e a pesquisa de similaridade semântica ao Aurora equipado com a extensão pgvector, arquitetamos um sistema preditivo dinâmico. Essa topologia garante que as respostas geradas sejam rigorosamente fundamentadas em verdades corporativas atualizadas, mitigando riscos de conformidade e fornecendo inteligência artificial escalável estritamente dentro dos limites da nuvem privada da AWS.

Pré-requisitos

A orquestração deste ecossistema exige proficiência em modelagem de espaços vetoriais e infraestrutura de computação sem servidor. O provisionamento requer o Terraform versão 1.7.0 ou superior acoplado ao provedor HashiCorp AWS versão 5.40.0. O ambiente de computação necessita do Python 3.12, a biblioteca boto3 versão 1.34.0 para comunicação com a API do Bedrock, a biblioteca psycopg (versão 3) para conexões ao banco de dados e o aws-lambda-powertools versão 2.34.0. É estritamente obrigatório acessar o console da AWS previamente e solicitar o acesso aos modelos fundacionais Anthropic Claude 3 e Amazon Titan Embeddings na região de implantação.

Passo a Passo

Vetorização e Indexação Semântica com Aurora PostgreSQL

A arquitetura RAG fundamenta-se na capacidade de traduzir texto não estruturado em representações matemáticas multidimensionais, conhecidas como embeddings. Provisionamos um cluster Amazon Aurora Serverless v2 executando PostgreSQL e habilitamos a extensão nativa pgvector. A justificativa arquitetônica para utilizar o Aurora em vez de um banco de dados vetorial de nicho é a consolidação operacional. Dados transacionais tradicionais e suas representações semânticas devem coexistir no mesmo limite de persistência para garantir integridade e simplificar a governança. O adaptador de ingestão invoca o modelo Amazon Titan Embeddings via Bedrock para converter o documento de negócios em um vetor flutuante e o persiste na tabela. Para otimizar a pesquisa de similaridade, criamos um índice HNSW (Hierarchical Navigable Small World), que entrega performance de busca sub-milissegundo mesmo operando sobre tabelas com milhões de registros textuais.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
resource "aws_rds_cluster" "vector_db" {
cluster_identifier = "enterprise-vector-store"
engine = "aurora-postgresql"
engine_mode = "provisioned"
engine_version = "15.4"
database_name = "knowledge_base"
master_username = "dbadmin"
manage_master_user_password = true

serverlessv2_scaling_configuration {
max_capacity = 16.0
min_capacity = 1.0
}
}

resource "aws_rds_cluster_instance" "vector_instance" {
cluster_identifier = aws_rds_cluster.vector_db.id
instance_class = "db.serverless"
engine = aws_rds_cluster.vector_db.engine
engine_version = aws_rds_cluster.vector_db.engine_version
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import json
import boto3
import psycopg
from aws_lambda_powertools import Logger

logger = Logger(service="EmbeddingIngestion")
bedrock_runtime = boto3.client('bedrock-runtime')

class VectorRepositoryAdapter:
def __init__(self, connection_string: str):
self.conn_str = connection_string

def generate_embedding(self, text: str) -> list[float]:
body = json.dumps({"inputText": text})
response = bedrock_runtime.invoke_model(
body=body,
modelId="amazon.titan-embed-text-v2:0",
accept="application/json",
contentType="application/json"
)
response_body = json.loads(response.get('body').read())
return response_body.get('embedding')

def persist_document(self, doc_id: str, content: str):
vector = self.generate_embedding(content)

with psycopg.connect(self.conn_str) as conn:
with conn.transaction():
# A extensão pgvector permite a inserção direta de matrizes flutuantes
conn.execute(
"INSERT INTO corporate_documents (id, content, embedding) VALUES (%s, %s, %s)",
(doc_id, content, vector)
)
logger.info(f"Documento {doc_id} vetorizado e indexado com sucesso.")
Como consultamos esse espaço multidimensional com segurança durante a fase de inferência sem expor as credenciais absolutas do banco de dados à camada efêmera de computação que interage com os usuários finais?

Recuperação Segura e Injeção de Contexto Lógico

Consultamos a base de dados vetorial implementando a autenticação do AWS IAM diretamente no motor do PostgreSQL, erradicando o risco de vazamento de senhas estáticas. O adaptador da função AWS Lambda, atuando como o orquestrador do RAG, intercepta a pergunta do usuário, converte a string em um vetor e executa uma consulta de similaridade baseada em distância de cosseno (<=>) contra o Aurora. A justificativa de design repousa na restrição matemática do escopo do LLM. O modelo fundacional operando no Amazon Bedrock é completamente apátrida (stateless). Ao injetarmos o texto dos documentos mais próximos semanticamente de volta no prompt (Context Injection), forçamos o modelo Anthropic Claude a limitar sua geração linguística estritamente à topologia de dados fornecida, suprimindo o risco de o modelo inferir respostas baseadas em seu treinamento público genérico.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class RagOrchestrationService:
def __init__(self, repo: VectorRepositoryAdapter):
self.repo = repo

def retrieve_context(self, question_vector: list[float]) -> str:
with psycopg.connect(self.repo.conn_str) as conn:
# Operador <=> executa busca otimizada por similaridade de cosseno
records = conn.execute(
"""
SELECT content FROM corporate_documents
ORDER BY embedding <=> %s::vector LIMIT 3
"""
,
(question_vector,)
).fetchall()

return "\n".join([row[0] for row in records])

def generate_answer(self, question: str) -> str:
question_vector = self.repo.generate_embedding(question)
context = self.retrieve_context(question_vector)

prompt = f"""
Você é um assistente corporativo. Responda à pergunta baseando-se ESTRITAMENTE no contexto fornecido.
Se a resposta não estiver no contexto, diga "Não possuo informações suficientes".

<contexto>
{context}
</contexto>

Pergunta: {question}
"""


body = json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1000,
"messages": [{"role": "user", "content": prompt}]
})

response = bedrock_runtime.invoke_model(
modelId="anthropic.claude-3-haiku-20240307-v1:0",
body=body
)
result = json.loads(response.get('body').read())
return result['content'][0]['text']
Se o processo transacional completo que envolve vetorização, pesquisa no banco e geração de inteligência consumir múltiplos segundos, como evitamos que o cliente enfrente tempos limite de rede severos e abandone a aplicação devido à alta latência aparente?

Mitigação de Latência com Invocação de Fluxo (Streaming)

Evitamos tempos limite e otimizamos a métrica crítica de percepção do usuário implementando invocações de fluxo de dados (Response Streaming) através da API do Amazon Bedrock. Em arquiteturas HTTP síncronas tradicionais, o cliente é forçado a aguardar a geração completa do último token matemático pelo LLM antes de receber qualquer byte de resposta. Esta topologia paralisa a experiência. Utilizando o método invoke_model_with_response_stream nativo do boto3, o adaptador Python intercepta os fragmentos gerados (chunks) em tempo real e os transmite imediatamente sobre uma conexão WebSocket do API Gateway ou via AWS Lambda Response Streaming. Essa arquitetura reduz a métrica Time To First Token (TTFT) para níveis sub-milissegundo, habilitando a interface cliente a renderizar o texto instantaneamente de forma fluida, mascarando integralmente a carga computacional do backend.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def generate_streaming_answer(self, prompt: str):
body = json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1000,
"messages": [{"role": "user", "content": prompt}]
})

response = bedrock_runtime.invoke_model_with_response_stream(
modelId="anthropic.claude-3-haiku-20240307-v1:0",
body=body
)

stream = response.get('body')
if stream:
for event in stream:
chunk = event.get('chunk')
if chunk:
# Decodifica e encaminha o fragmento imediatamente para o canal de saída
chunk_obj = json.loads(chunk.get('bytes').decode())
if chunk_obj['type'] == 'content_block_delta':
text_fragment = chunk_obj['delta']['text']
yield text_fragment

Solução de Problemas Comuns

Quando a invocação do Amazon Bedrock falha com a emissão imediata de uma exceção AccessDeniedException, o problema raramente tem origem nas políticas do AWS IAM anexadas à função de computação. Este sintoma indica categoricamente que o contrato de licença de usuário final (EULA) do modelo fundacional específico não foi aceito manualmente através da console do serviço. Os modelos no Bedrock exigem uma liberação (opt-in) explícita por região antes que qualquer tráfego via API seja autorizado a interagir com os tensores da rede neural.
Erros de sintaxe estrutural relatando different exact dimensions durante a inserção de vetores no Aurora PostgreSQL revelam uma assimetria matemática entre o modelo de embedding empregado e o esquema da tabela. O modelo Amazon Titan Embeddings v2 gera matrizes contendo exatamente 1536 dimensões flutuantes. Se a instrução Data Definition Language (DDL) definir a coluna como vector(768) ou omitir o tamanho rígido dimensional, o banco de dados rejeitará a gravação para preservar a consistência das operações de distância euclidiana. Valide o esquema garantindo a correspondência dimensional exata exigida pelo modelo de fundação configurado em tempo de execução.

Conclusão

A integração transacional do Amazon Bedrock com o Aurora PostgreSQL equipado com pgvector instaura uma solução definitiva para a implantação de inteligência artificial governada em escala corporativa. Ao enclausurar o contexto base no domínio de banco de dados e restringir os modelos de fundação a atuações puramente linguísticas e apátridas, as organizações consolidam operações auditáveis e isentas de alucinações cognitivas. Arquitetos responsáveis por escalar esta topologia devem migrar o gerenciamento direto do vetor para o serviço Knowledge Bases for Amazon Bedrock, unificando a sincronização através de pipelines automatizados de ingestão e adotando estratégias de pesquisa híbrida para amalgamar a precisão léxica estrita com a expansão semântica profunda.

Referências

Amazon Web Services. (2024). Vector datastores and embeddings using Amazon Aurora PostgreSQL and pgvector. AWS Architecture Center. https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/postgresql-ml-pgvector.html 
Anthropic. (2024). Claude 3 Prompt Engineering Guide: Using contextual retrieval. Anthropic Documentation.
Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., ... & Stoyanov, V. (2020). Retrieval-augmented generation for knowledge-intensive NLP tasks. Advances in Neural Information Processing Systems, 33, 9459-9474.
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