AWS HubAWS HubSão Paulo operando · 2 eventos no mundo

BedrockIA Generativa

Nível de dificuldade: Avançado (4 de 5)

Como auditar cada resposta de um chatbot RAG no Aurora PostgreSQL com Bedrock

Por AWS Hub9 min de leitura

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ção aws_bedrock.invoke_model_get_embeddings do 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 tabela chat_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.

AbordagemQuando faz sentidoO que você ganha
Amazon Bedrock Knowledge BasesO comportamento padrão de retrieval e citação já atendeRAG pronto, menos código para manter
Logging customizado no Aurora PostgreSQL (este tutorial)Precisa de proveniência no próprio schema, auditável via SQLControle 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 pgvector habilitada; índices HNSW e iterative index scans exigem versões mais novas do pgvector, então confira a versão mínima atual na documentação em vez de fixar um número.
  • A extensão aws_ml habilitada (CREATE EXTENSION IF NOT EXISTS aws_ml CASCADE), com uma role IAM anexada ao cluster concedendo bedrock:InvokeModel. O Aurora ML chama o Bedrock na mesma região do cluster, então rode isso em sa-east-1 se quiser manter os dados em São Paulo.
  • A extensão aws_s3 habilitada (CREATE EXTENSION IF NOT EXISTS aws_s3 CASCADE), com role IAM para o recurso s3Export, usada pelo job de retenção.
  • Acesso ao Amazon Bedrock ao modelo amazon.titan-embed-text-v2:0 para 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 pgaudit e pg_cron ao shared_preload_libraries existente (acrescente, não substitua, para preservar padrões como pg_stat_statements; isso exige reinício do cluster). Defina cron.database_name para o banco de destino.
  • Familiaridade básica com PostgreSQL, SQL e Python.

Passo a passo

1. Crie o schema e as tabelas de log

sql
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.

sql
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

sql
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:

sql
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.

sql
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:

python
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:

sql
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:

python
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.customers e associe um tenant_id a alguns registros de knowledge_chunks.
  • Rode o UPDATE de embeddings e confirme que a coluna embedding não ficou nula com SELECT 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 se chat_interactions.citations lista exatamente os chunk_id que 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_text nem em response_text depois da redação.

Limpando os recursos

Apague, nesta ordem, para não deixar nada gerando cobrança:

  1. As tabelas do schema: DROP SCHEMA rai_postgresql CASCADE; remove customers, knowledge_chunks, chat_interactions e chat_feedback de uma vez.
  2. O índice HNSW já cai junto com a tabela, mas confira se não sobrou um índice órfão em outro schema de teste.
  3. O Guardrail criado no Bedrock, se foi provisionado só para este tutorial (console do Bedrock > Guardrails > Delete).
  4. As roles IAM criadas para bedrock:InvokeModel e para o s3Export, se não forem reutilizadas em outro projeto.
  5. O bucket do Amazon S3 usado para o arquivamento via pg_cron, incluindo os objetos já expurgados.
  6. 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.
  7. 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 pgaudit junto 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ã?

Newsletter semanal

A semana da AWS, em português

Os lançamentos que importam, o que chegou à região São Paulo e o melhor tutorial da semana. Toda sexta, gratuita.