BedrockIA Generativa
Nível de dificuldade: Avançado (4 de 5)
Como auditar cada resposta de um chatbot RAG no Aurora PostgreSQL com Bedrock
Em números
- 1.024 dimensões nos vetores que o Titan Text Embeddings V2 gera para cada trecho de texto indexado
- 0,7 é o corte mínimo de similaridade de cosseno usado para descartar trechos fracos antes de montar o prompt
- 5 é o número de trechos retornados por consulta no exemplo de SQL (
LIMIT 5) - 90 dias é o prazo de retenção dos registros de interação antes do expurgo para o Amazon S3
O AWS Machine Learning Blog publicou um guia de referência para implementar um chatbot de suporte ao cliente com RAG (Retrieval Augmented Generation) sobre o Amazon Aurora PostgreSQL-Compatible Edition, tratando a explicabilidade como requisito de arquitetura, não como funcionalidade extra. O documento mapeia as oito dimensões de AWS Responsible AI (Fairness, Explainability, Privacy and Security, Safety, Controllability, Veracity and Robustness, Governance e Transparency) a recursos concretos do PostgreSQL, mas implementa só uma delas em profundidade: Explainability. É a primeira parte de uma série.
O recorte interessa direto a quem constrói agentes e aplicações de IA generativa sobre dados próprios no Brasil: um chatbot que responde "por que minha fatura veio alta" sem conseguir mostrar qual ticket, qual score de similaridade e qual trace de Guardrail geraram aquela resposta não passa em nenhuma auditoria de compliance séria. Este tutorial reconstrói o design pattern da fonte, com os comandos e o SQL necessários para colocar isso de pé.
O que você vai construir
Um pipeline de RAG sobre Aurora PostgreSQL que não só responde perguntas, mas também registra a proveniência completa de cada resposta. O fluxo final:
- Um usuário manda uma pergunta via Amazon API Gateway.
- O AWS Lambda transforma a pergunta em vetor com
amazon.titan-embed-text-v2:0(Titan Text Embeddings V2), pela funçãoaws_bedrock.invoke_model_get_embeddingsdo Aurora ML. - O Aurora PostgreSQL faz busca por similaridade de cosseno com
pgvector, isolando os resultados por tenant via Row-Level Security. - O Lambda monta o prompt com os trechos recuperados (rotulados
[Source N]), chama o Bedrock Converse API com Guardrails ativos para checagem de PII, conteúdo e grounding contextual, e devolve a resposta com citações. - Toda a interação (pergunta, chunks recuperados, scores, citações, trace do Guardrail e
model_id) é gravada na tabelachat_interactions.
Isso não é uma alternativa ao Amazon Bedrock Knowledge Bases, que já entrega RAG pronto com citações. É o caminho para quando você precisa de proveniência guardada no seu próprio schema, consultável via SQL e retida sob a sua própria política, em vez de confiar na caixa-preta de um serviço gerenciado.
| Abordagem | Quando faz sentido | O que você ganha |
|---|---|---|
| Amazon Bedrock Knowledge Bases | O comportamento padrão de retrieval e citação já atende | RAG pronto, menos código para manter |
| Logging customizado no Aurora PostgreSQL (este tutorial) | Precisa de proveniência no próprio schema, auditável via SQL | Controle total sobre retenção, score de similaridade e trace do Guardrail |
Pré-requisitos
Antes de começar, você precisa ter:
- Um cluster Amazon Aurora PostgreSQL com a extensão
pgvectorhabilitada; índices HNSW e iterative index scans exigem versões mais novas dopgvector, então confira a versão mínima atual na documentação em vez de fixar um número. - A extensão
aws_mlhabilitada (CREATE EXTENSION IF NOT EXISTS aws_ml CASCADE), com uma role IAM anexada ao cluster concedendobedrock:InvokeModel. O Aurora ML chama o Bedrock na mesma região do cluster, então rode isso emsa-east-1se quiser manter os dados em São Paulo. - A extensão
aws_s3habilitada (CREATE EXTENSION IF NOT EXISTS aws_s3 CASCADE), com role IAM para o recursos3Export, usada pelo job de retenção. - Acesso ao Amazon Bedrock ao modelo
amazon.titan-embed-text-v2:0para embeddings, mais um foundation model que suporte a Bedrock Converse API para gerar as respostas. Modelos mais novos são chamados via inference profile IDs cross-region. - Um Amazon Bedrock Guardrail configurado com proteção de PII, filtro de conteúdo e a política de contextual grounding habilitada.
- Roles IAM com permissão mínima para Bedrock, Lambda e Aurora PostgreSQL.
- Um parameter group customizado do cluster adicionando
pgauditepg_cronaoshared_preload_librariesexistente (acrescente, não substitua, para preservar padrões comopg_stat_statements; isso exige reinício do cluster). Definacron.database_namepara o banco de destino. - Familiaridade básica com PostgreSQL, SQL e Python.
Passo a passo
1. Crie o schema e as tabelas de log
CREATE SCHEMA IF NOT EXISTS rai_postgresql;
CREATE TABLE rai_postgresql.customers (
customer_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
full_name VARCHAR(150) NOT NULL,
email VARCHAR(255) UNIQUE NOT NULL,
phone VARCHAR(20),
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
is_active BOOLEAN DEFAULT TRUE,
metadata JSONB DEFAULT '{}'
);A tabela chat_interactions é o núcleo da explicabilidade: guarda os chunks recuperados, os scores de similaridade, as citações efetivamente usadas (versus tudo que foi recuperado) e o trace completo do Guardrail.
CREATE TABLE rai_postgresql.chat_interactions (
interaction_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
session_id UUID NOT NULL,
customer_id UUID NOT NULL REFERENCES rai_postgresql.customers(customer_id),
request_text TEXT NOT NULL,
response_text TEXT,
response_latency_ms INTEGER,
retrieved_chunk_ids UUID[],
similarity_scores NUMERIC[],
citations JSONB,
guardrail_assessment JSONB,
model_id VARCHAR(100),
guardrail_version VARCHAR(20)
);Como essa tabela guarda request_text e response_text em texto puro, trate-a com o mesmo cuidado que a fonte dos dados: redija PII antes do INSERT, ou cifre essas colunas com pgcrypto, e aplique Row-Level Security também nos logs. Logar conteúdo de cliente sem proteção anula o próprio controle de privacidade que o design deveria demonstrar.
2. Prepare a base de conhecimento com pgvector e Aurora ML
CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION IF NOT EXISTS aws_ml CASCADE;
CREATE TABLE rai_postgresql.knowledge_chunks (
chunk_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
ticket_id UUID NOT NULL,
content TEXT NOT NULL,
embedding VECTOR(1024),
metadata JSONB,
tenant_id UUID,
created_at TIMESTAMP DEFAULT NOW()
);
CREATE INDEX idx_chunks_embedding ON rai_postgresql.knowledge_chunks
USING hnsw (embedding vector_cosine_ops);Isole os dados por tenant com Row-Level Security antes que qualquer resultado saia do banco:
ALTER TABLE rai_postgresql.knowledge_chunks ENABLE ROW LEVEL SECURITY;
ALTER TABLE rai_postgresql.knowledge_chunks FORCE ROW LEVEL SECURITY;
CREATE ROLE app_user;
GRANT USAGE ON SCHEMA rai_postgresql TO app_user;
GRANT SELECT ON rai_postgresql.knowledge_chunks TO app_user;
CREATE POLICY tenant_isolation ON rai_postgresql.knowledge_chunks
USING (
current_setting('app.current_tenant', true) IS NOT NULL
AND tenant_id = current_setting('app.current_tenant', true)::uuid
);3. Gere os embeddings direto do SQL
O ponto de alavancagem do Aurora ML é não precisar de Lambda nem de boto3 para gerar embedding: a chamada ao Bedrock acontece dentro do próprio UPDATE.
UPDATE rai_postgresql.knowledge_chunks
SET embedding = aws_bedrock.invoke_model_get_embeddings(
'amazon.titan-embed-text-v2:0',
'application/json',
'embedding',
json_build_object('inputText', content)::text
)::vector
WHERE embedding IS NULL;Antes de chegar a esse UPDATE, redija PII no pipeline de ingestão, com a ApplyGuardrail API do Bedrock ou a detect_pii_entities do Amazon Comprehend:
response = bedrock.apply_guardrail(
guardrailIdentifier=guardrail_id,
source='INPUT',
content=[{'text': {'text': raw_text}}]
)
redacted_text = (response['outputs'][0]['text']
if response.get('outputs') else raw_text)Note que a ApplyGuardrail só mascara texto se a política do Guardrail estiver configurada como ANONYMIZE, e não como BLOCK; com BLOCK o conteúdo é rejeitado, não redigido.
4. Recupere contexto e gere a resposta
Na consulta, filtre por tenant e descarte trechos fracos com o corte de similaridade:
SET LOCAL app.current_tenant = '11111111-1111-1111-1111-111111111111';
SELECT chunk_id, content, metadata,
1 - (embedding <=> :query_embedding::vector) AS cosine_similarity
FROM rai_postgresql.knowledge_chunks
WHERE metadata ->> 'category' = :intent_category
AND 1 - (embedding <=> :query_embedding::vector) >= 0.7
ORDER BY embedding <=> :query_embedding::vector
LIMIT 5;O filtro de categoria e o corte de 0,7 agem depois da busca HNSW, então podem devolver menos de cinco linhas; se isso for um problema, suba hnsw.ef_search ou use iterative index scans (disponível a partir do pgvector 0.8.0).
Para que o Bedrock avalie se a resposta está de fato ancorada no contexto recuperado, use blocos guardContent na Converse API, marcando o que é fonte de grounding e o que é a pergunta do usuário:
response = bedrock.converse(
modelId=model_id,
messages=[{'role': 'user', 'content': [
{'guardContent': {'text': {'text': context, 'qualifiers': ['grounding_source']}}},
{'guardContent': {'text': {'text': query, 'qualifiers': ['query']}}},
{'text': prompt}
]}],
guardrailConfig={'guardrailIdentifier': guardrail_id,
'guardrailVersion': '1', 'trace': 'enabled'},
inferenceConfig={'maxTokens': 500, 'temperature': 0.1}
)Com trace: enabled, a resposta traz o guardrail_assessment completo, que é exatamente o campo JSONB gravado em chat_interactions. Verifique o stopReason da resposta: se o Guardrail bloquear o conteúdo, trate isso como um caminho de erro explícito, não como uma resposta normal truncada.
Testando
- Insira um cliente de teste em
rai_postgresql.customerse associe umtenant_ida alguns registros deknowledge_chunks. - Rode o
UPDATEde embeddings e confirme que a colunaembeddingnão ficou nula comSELECT count(*) FROM rai_postgresql.knowledge_chunks WHERE embedding IS NULL;(o esperado é zero). - Simule a pergunta "Why was my last bill high?" (ou a tradução equivalente para o seu domínio), passando pelo fluxo de embedding, busca e
Converse, e confira sechat_interactions.citationslista exatamente oschunk_idque aparecem na resposta final, não todos os que foram recuperados. - Consulte o trace do Guardrail de uma interação específica:
SELECT guardrail_assessment FROM rai_postgresql.chat_interactions WHERE interaction_id = '...';e verifique se a checagem de grounding contextual aparece no JSON. - Teste um caso de PII proposital no texto de entrada (um número de telefone fictício, por exemplo) e confirme que ele não aparece em
request_textnem emresponse_textdepois da redação.
Limpando os recursos
Apague, nesta ordem, para não deixar nada gerando cobrança:
- As tabelas do schema:
DROP SCHEMA rai_postgresql CASCADE;removecustomers,knowledge_chunks,chat_interactionsechat_feedbackde uma vez. - O índice HNSW já cai junto com a tabela, mas confira se não sobrou um índice órfão em outro schema de teste.
- O Guardrail criado no Bedrock, se foi provisionado só para este tutorial (console do Bedrock > Guardrails > Delete).
- As roles IAM criadas para
bedrock:InvokeModele para os3Export, se não forem reutilizadas em outro projeto. - O bucket do Amazon S3 usado para o arquivamento via
pg_cron, incluindo os objetos já expurgados. - O cluster Aurora PostgreSQL inteiro, se ele foi criado só para o teste; um cluster Aurora fora do Free Tier cobra por hora de instância e por armazenamento, independentemente de estar sendo consultado.
- O parameter group customizado associado ao cluster, se não for usado por outro recurso.
A chamada ao Titan Text Embeddings V2 e ao modelo de geração via Bedrock sai do Free Tier e é cobrada por token processado; a fonte não traz valores de preço, então confira a tabela de preços atual do Bedrock antes de rodar o pipeline em volume.
Próximos passos
Este tutorial cobre só a dimensão de Explainability, uma das oito do framework AWS Responsible AI descrito no AWS Well-Architected Responsible AI Lens e no Responsible Use of AI Guide. A própria AWS trata este post como a Parte 1 de uma série, o que significa que Fairness, Privacy and Security, Safety, Controllability, Veracity and Robustness, Governance e Transparency ainda ficam de fora de uma implementação completa.
- Para Fairness, o caminho indicado é testar o chatbot com consultas multilíngues e usar o Amazon SageMaker Clarify para medir viés, mantendo dados demográficos fora dos embeddings.
- Para Governance, vale configurar o
pgauditjunto com o AWS Audit Manager e o AWS CloudTrail para formar uma trilha de auditoria completa, não só o log de interações. - Para Transparency, o padrão mais simples é expor um aviso de "powered by AI" na interface e reaproveitar as mesmas citações já gravadas em
chat_interactions.citations.
Se o seu caso de uso não precisa de controle fino sobre retenção e schema, vale reavaliar se o Amazon Bedrock Knowledge Bases, com RAG e citações nativas, não resolve o mesmo problema com bem menos código para manter.
Fonte: AWS Machine Learning Blog
Serviços neste textoBedrockAgentes
Leve para a sua IA
Decida com o seu assistente, com o contexto deste texto já montado.
1. O que você quer saber
Ver o prompt
Li no AWS Hub: "Como auditar cada resposta de um chatbot RAG no Aurora PostgreSQL com Bedrock" (https://awshub.com.br/ia/como-auditar-cada-resposta-de-um-chatbot-rag-no-aurora-postgresql-com-bedrock). Resumo: A AWS publicou um guia mostrando como logar, no próprio Aurora PostgreSQL, cada trecho recuperado, o score de similaridade e o trace do Guardrail por trás de uma resposta gerada pelo Bedrock. Isso é o que separa um protótipo de RAG de um sistema auditável em produção. Fonte oficial: https://aws.amazon.com/blogs/machine-learning/design-responsible-ai-controls-for-amazon-aurora-postgresql/ Serviços: Bedrock, Agentes Minha stack: [descreva em uma linha: serviços, linguagem, volume, região] Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?