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

BedrockComunidade

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

Reranking com cross-encoder no SageMaker evita o erro de jogar tudo no LLM em RAG

Por AWS Hub8 min de leitura

A quarta parte da série DocLab mostra como um cross-encoder BGE rodando no SageMaker reduz 15 candidatos de busca híbrida a 3 chunks de alta confiança antes de streamar a resposta pelo Bedrock ConverseStream.

Quem monta pipeline de RAG em produção conhece o atalho perigoso: a busca híbrida devolve uma dúzia de chunks relevantes e o engenheiro simplesmente empilha tudo no prompt do LLM, torcendo para o modelo separar o que importa. A quarta parte da série DocLab, publicada por Naga Chaitanya Inamdar no DEV Community, documenta por que esse atalho quebra em escala e como resolver com um estágio dedicado de reranking antes de chamar o Bedrock.

Na parte 3 da série, Inamdar já tinha montado o que ele chama de Storage Vault: um PostgreSQL 16 com pgvector para embeddings densos e um índice tsvector para BM25, combinados via Reciprocal Rank Fusion (RRF) para gerar um pool de 15 chunks candidatos. O problema começa no próximo passo, quando a maioria dos times simplesmente encaminha esses 15 chunks ao LLM.

O que você vai construir

Este tutorial reproduz o Stage 2 da arquitetura DocLab: um endpoint de inferência em tempo real no SageMaker rodando o cross-encoder BAAI/bge-reranker-base, que recebe os 15 candidatos do RRF e devolve os 3 chunks com maior confiança. Em seguida, você monta um prompt com guardrail usando só esses 3 chunks e transmite a resposta do Bedrock via ConverseStream, entregando tokens ao navegador por Server-Sent Events (SSE).

O ganho não é cosmético. Segundo a fonte, dense retrieval sozinho (Amazon Titan v2) e BM25 sozinho cometem erros opostos: o vetor denso encontra a resposta certa mas não discrimina bem o score; o BM25 acerta por palavra-chave mas erra feio quando a pergunta é semântica. O cross-encoder resolve os dois problemas ao custo de rodar sobre um conjunto já filtrado, não sobre a base inteira.

Para alcançar confiabilidade em produção, uma plataforma corporativa precisa de um reranker dedicado de precisão em segundo estágio.

To achieve production reliability, an enterprise platform requires a dedicated Stage-2 Precision Reranker.Naga Chaitanya Inamdar, autor da série DocLab no DEV Community

Por que um cross-encoder e não só mais embedding

Todo modelo de embedding usado em retrieval (Titan v2, text-embedding-3 da OpenAI, Cohere) é um bi-encoder: a query vira um vetor E(Q), o documento vira outro vetor E(D) de forma independente, e a similaridade é o produto escalar entre os dois. O defeito estrutural é que os tokens da query nunca interagem com os tokens do documento dentro das camadas de atenção; tudo já foi comprimido em um vetor fixo antes da comparação.

Um cross-encoder como o bge-reranker-base passa a query e o chunk juntos, num único input ([CLS] query [SEP] documento [EOS]), e deixa a atenção cruzar cada token da pergunta com cada token do texto. O resultado não é mais um vetor: é uma probabilidade calibrada de relevância entre 0 e 1. É mais caro computacionalmente, por isso ninguém roda isso contra 100 mil documentos; mas contra 15 candidatos já filtrados, o custo vira irrelevante.

Pré-requisitos

  • Conta AWS com permissão para sagemaker:CreateModel, CreateEndpointConfig, CreateEndpoint e InvokeEndpoint (e para desfazer tudo: DeleteEndpoint, DeleteEndpointConfig, DeleteModel).
  • Acesso liberado ao modelo que você for usar no Bedrock (habilitar em Model access no console) e permissão IAM para bedrock:InvokeModelWithResponseStream ou bedrock:Converse/ConverseStream, dependendo do SDK.
  • SageMaker Python SDK atualizado (pip install sagemaker) e acesso ao Hugging Face Hub para baixar os pesos de BAAI/bge-reranker-base.
  • O pipeline de busca híbrida da parte 3 já funcionando: Postgres 16 com pgvector e índice tsvector, devolvendo o pool de 15 candidatos via RRF.
  • Quota liberada para pelo menos uma instância ml.m5.large em SageMaker real-time inference (checar em Service Quotas antes de tentar criar o endpoint).
  • Um backend capaz de abrir uma resposta text/event-stream; a fonte usa Spring Boot, mas qualquer runtime com suporte a SSE serve.

Passo a passo

Nota da redação: o código desta seção não foi executado em ambiente real pela nossa redação. Valide antes de usar em produção.

1. Empacotar e implantar o cross-encoder no SageMaker. O modelo BAAI/bge-reranker-base é publicado como modelo Hugging Face padrão, então o deploy usa o container de inferência gerenciado:

python
from sagemaker.huggingface import HuggingFaceModel

hf_model = HuggingFaceModel(
 model_data=None, # baixa direto do Hub no primeiro deploy
 env={"HF_MODEL_ID": "BAAI/bge-reranker-base", "HF_TASK": "text-classification"},
 role=sagemaker_execution_role,
 transformers_version="4.37",
 pytorch_version="2.1",
 py_version="py310",
)

predictor = hf_model.deploy(
 initial_instance_count=1,
 instance_type="ml.m5.large",
 endpoint_name="bge-reranker-endpoint",
)

2. Escolher endpoint provisionado em vez de serverless. A tentação de usar SageMaker Serverless Inference para zerar custo ocioso é real, mas Inamdar é direto sobre o trade-off: cold start de container PyTorch carregando os pesos leva de 5 a 10 segundos sempre que o endpoint escala do zero. Uma instância ml.m5.large provisionada custa cerca de ~$0,115/hora (~$80/mês) e garante inferência determinística abaixo de 50ms mesmo sob pico de tráfego, sem cold start. Para um chat que promete resposta em menos de 400ms, serverless não é opção.

3. Fixar o contrato de entrada e saída. O backend envia a query e os textos candidatos num único payload; o endpoint devolve o índice e o score de cada par:

json
{
 "query": "What are the scaling policies defined for checkout-service?",
 "texts": [
 "Chunk A: Service catalog for checkout-service specifying horizontal pod autoscaler...",
 "Chunk B: Payment gateway timeout and retry threshold definitions...",
 "Chunk C: ADR-025 Ingestion Factory architectural decision record..."
 ]
}
json
[
 { "index": 0, "score": 0.9970 },
 { "index": 2, "score": 0.4120 },
 { "index": 1, "score": 0.0381 }
]

4. Aplicar threshold e ordenar. O backend ordena por score decrescente e descarta qualquer chunk abaixo de um limiar configurável (0,60 na implementação da fonte), mantendo só os 3 primeiros. Esse corte é o que elimina ruído antes de o LLM ver qualquer coisa.

5. Montar o prompt com guardrail fail-closed. Em vez de confiar na boa vontade do modelo, o prompt instrui explicitamente a recusar resposta fora do contexto:

text
System:
You are an enterprise AI assistant for DocLab.
Rules:
1. Answer strictly and exclusively using the provided context chunks below.
2. If the answer cannot be found in the context, explicitly say:
"I cannot answer this question based on the verified enterprise documentation."
3. Cite the Chunk ID for every factual assertion made.
4. Do not speculate or extrapolate beyond the text.

6. Chamar o Bedrock ConverseStream e expor via SSE. O backend abre o stream reativo do Bedrock e repassa cada delta de token direto ao cliente num endpoint próprio:

http
GET /api/v1/chat/stream?query=...&allowedRoles=ROLE_ANALYST
text
event: delta
data: {"token": "The "}

data: {"token": "checkout-service "}

data: {"token": "scales "}

data: {"token": "automatically..."}

Testando

A fonte roda o benchmark contra um corpus corporativo real: ADRs (Architectural Decision Records), planilhas Excel e catálogos de serviço em JSON. Para a pergunta sobre política de escalonamento do checkout-service, o dense retrieval (Titan v2) acerta o chunk certo mas com confiança 0,8841, numa faixa que não dá para usar como corte absoluto. O BM25 sozinho simplesmente erra (score 0). O híbrido com RRF (k=60) reordena, mas com um score de 0,01639, quase inútil para decidir threshold.

O cross-encoder muda a escala do problema: o chunk certo sobe para 0,9970 de confiança, e os irrelevantes despencam para abaixo de 0,05. Essa separação nítida é o que permite usar um threshold fixo (0,60) em produção sem recalibrar por query. Em outro teste, sobre uma consequência registrada na ADR-025, o padrão muda: o BM25 sozinho acerta em primeiro lugar (score 12.41) e o dense retrieval também aponta para o chunk certo (0,8120), mas o híbrido com RRF produz um score baixo e pouco discriminante (0,03226). Mesmo com esses sinais divergentes no primeiro estágio, o cross-encoder confirma a resposta certa com 0,9957 de confiança.

Para validar o endpoint isoladamente, sem subir todo o pipeline, dá para invocar o SageMaker direto via CLI:

bash
aws sagemaker-runtime invoke-endpoint \
 --endpoint-name bge-reranker-endpoint \
 --content-type application/json \
 --body '{"query":"scaling policy checkout-service","texts":["..."]}' \
 output.json

A fonte mediu a janela completa em infraestrutura AWS real: 15ms na busca híbrida do Postgres, 40ms no reranking do SageMaker, e 325ms até o primeiro token do Bedrock chegar à tela. Total de 380ms de Time-to-First-Token, com o resto da resposta chegando em stream. O efeito colateral que mais importa para quem paga a fatura de tokens: enviar 3 chunks em vez de 15 cortou o consumo de tokens de prompt em 72%, segundo o artigo.

Limpando os recursos

Um endpoint ml.m5.large provisionado cobra por hora rodando, esteja ele recebendo tráfego ou não (é o preço de ter latência determinística sem cold start). Para não deixar a conta correndo depois do teste, apague os três recursos criados, nesta ordem:

bash
aws sagemaker delete-endpoint --endpoint-name bge-reranker-endpoint
aws sagemaker delete-endpoint-config --endpoint-config-name bge-reranker-endpoint
aws sagemaker delete-model --model-name bge-reranker-endpoint-model

Se você também subiu o Postgres com pgvector da parte 3 só para este teste, pare ou apague a instância RDS correspondente; ela não faz parte deste tutorial, mas é a outra ponta que continua cobrando se ficar esquecida.

Próximos passos

Inamdar anuncia a parte 5 da série, descrita como o fechamento da arquitetura: isolamento multi-tenant de cache com ElastiCache Redis, guardrails contra prompt injection e exfiltração de dados, e uma revisão de custo total do projeto rodando sob ~$200 em créditos AWS.

Fonte: DEV Community — #aws

Serviços neste textoBedrockSageMakerAgentes

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: "Reranking com cross-encoder no SageMaker evita o erro de jogar tudo no LLM em RAG" (https://awshub.com.br/comunidade/reranking-com-cross-encoder-no-sagemaker-evita-o-erro-de-jogar-tudo-no-llm-em-ra).
Resumo: A quarta parte da série DocLab mostra como um cross-encoder BGE rodando no SageMaker reduz 15 candidatos de busca híbrida a 3 chunks de alta confiança antes de streamar a resposta pelo Bedrock ConverseStream.
Serviços: Bedrock, SageMaker, 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.