Por Medha
Cenário (sintético)
Um usuário perguntou ao assistente de suporte: "o que significa o ERRO-4032 no checkout?". A base de conhecimento tinha, sim, um artigo inteiro sobre o ERRO-4032. A resposta do assistente foi genérica, sobre "problemas comuns de pagamento", sem citar o artigo certo.
O time abriu uma investigação achando que era um caso de alucinação do modelo. Não era. Ao inspecionar os chunks que tinham sido recuperados e enviados ao modelo naquela consulta, o artigo do ERRO-4032 simplesmente não estava entre eles. A busca vetorial, sozinha, tratou "ERRO-4032" como um token qualquer e priorizou chunks semanticamente parecidos com "erro" e "checkout" em geral — mas nenhum deles era o artigo certo, porque o código exato do erro se perdeu no espaço semântico do embedding.
O modelo respondeu exatamente com o que recebeu. O problema não era o modelo. Era o retrieval.
Busca vetorial sozinha tem um ponto cego: correspondência exata
Busca por embedding (vetorial) é ótima para capturar sinônimo e paráfrase: "cancelar minha assinatura" e "encerrar o plano" ficam próximos no espaço vetorial mesmo sem nenhuma palavra em comum. Mas embedding não foi desenhado para privilegiar correspondência exata de um token específico — código de erro, número de contrato, sigla interna, nome próprio raro. Nesses casos, um chunk que contém a string exata "ERRO-4032" pode ficar atrás de chunks apenas "parecidos" no ranking puramente semântico.
Busca por palavra-chave (BM25, a mesma família de algoritmo usada por motores de busca tradicionais) resolve exatamente esse ponto cego: ela pontua alto um documento que contém o termo exato da consulta, independente de sinônimo. A fraqueza do BM25 é o oposto da busca vetorial: se o usuário usa uma palavra diferente da que está no documento, BM25 não faz a ponte semântica.
Busca híbrida combina as duas: roda BM25 e busca vetorial em paralelo, e funde os dois rankings em um único resultado. Uma forma simples e amplamente usada de fazer essa fusão é o reciprocal rank fusion (RRF), que soma, para cada chunk, o inverso da posição dele em cada ranking de origem:
def reciprocal_rank_fusion(rankings: list[list[str]], k: int = 60) -> list[str]:
"""Combina múltiplos rankings (ex.: BM25 e busca vetorial) somando
o escore de posição recíproca de cada chunk em cada lista de
entrada. Quanto mais perto do topo em mais listas, maior o escore
final."""
scores: dict[str, float] = {}
for ranking in rankings:
for posicao, chunk_id in enumerate(ranking):
scores[chunk_id] = scores.get(chunk_id, 0.0) + 1.0 / (k + posicao + 1)
return sorted(scores, key=scores.get, reverse=True)
Com busca híbrida, o chunk do ERRO-4032 apareceria bem posicionado no ranking do BM25 (correspondência exata do código) mesmo que estivesse mal posicionado no ranking vetorial — e a fusão dos dois o traria para perto do topo.
Reranking: um segundo filtro, mais caro e mais preciso
Busca híbrida melhora o conjunto de candidatos, mas ainda ordena por um escore relativamente barato de calcular. Um reranker (tipicamente um cross-encoder, que compara a pergunta e cada chunk candidato par a par, em vez de comparar vetores pré-calculados) reordena um número menor de candidatos — por exemplo, os 20 ou 50 primeiros da busca híbrida — com um modelo mais caro computacionalmente, mas mais sensível ao significado real da pergunta em relação a cada chunk específico.
O padrão de uso mais comum é: busca híbrida traz um conjunto amplo de candidatos com custo baixo, reranking refina esse conjunto reduzido com custo mais alto, e só os poucos primeiros do reranking (3 a 10, dependendo do caso) vão para o contexto do modelo. Isso evita pagar o custo do reranker em toda a base, e evita mandar para o modelo um contexto poluído com candidatos ruins que a busca inicial trouxe.
Como saber se o problema é retrieval, e não o modelo
O diagnóstico mais direto: registrar, para cada consulta, exatamente quais chunks foram recuperados e enviados ao modelo. Depois, checar se o trecho que continha a resposta correta estava entre eles.
def diagnosticar_falha(resposta_esperada_contem: str, chunks_recuperados: list[str]) -> str:
"""Diagnóstico simples: se o trecho esperado não está entre os
chunks recuperados, o problema é de retrieval. Se está, e a
resposta ainda saiu errada, o problema é de geração/prompt."""
encontrado = any(resposta_esperada_contem.lower() in c.lower() for c in chunks_recuperados)
if not encontrado:
return "problema de retrieval: o chunk correto nunca chegou ao modelo"
return "chunk correto foi recuperado: investigar prompt ou geração, não o retrieval"
Sem esse registro, toda falha de resposta vira suspeita de "o modelo alucinou" — e o time pode passar semanas ajustando prompt para um problema que está na etapa de busca, não na etapa de geração.
Critério prático de aceite para a etapa de recuperação
- A busca combina sinal léxico (BM25 ou equivalente) e sinal semântico (vetorial), em vez de depender só de um dos dois?
- Existe reranking sobre o conjunto de candidatos antes de decidir o que entra no contexto do modelo?
- O sistema registra, por consulta, quais chunks foram recuperados — não só a resposta final — para permitir diagnóstico depois do fato?
- Antes de atribuir uma resposta errada ao modelo, alguém verificou se o chunk certo sequer foi recuperado?
Próximo passo
Até aqui a série tratou de fazer o documento certo chegar ao modelo. A partir da próxima peça, o foco muda para saber quando o sistema está pronto para produção — começando pelos critérios de aceite de um RAG.
Para aplicar este critério e os outros da série, fique de olho no Checklist de RAG em Produção, gratuito — ainda em preparação: deixe seu e-mail na lista de espera para recebê-lo assim que ele sair.