Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Reranking: Melhorar a Relevância

Aula 13 de 22 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Objetivos
  2. O Problema do Bi-Encoder
  3. Reranking com a Cohere
  4. Reranking com um LLM
  5. Integração no Pipeline RAG
  6. Impacto do Reranking
  7. Pontos-chave

Objetivos

  • Compreender por que o reranking melhora os resultados
  • Implementar um reranker utilizando um cross-encoder
  • Integrar o reranking num pipeline RAG

O Problema do Bi-Encoder

Toda a pesquisa que construiu até agora baseia-se num bi-encoder: a consulta e os documentos são codificados separadamente, de forma autónoma, e comparados através de um produto escalar. É isto que torna a pesquisa instantânea mesmo entre um milhão de fragmentos, uma vez que os vetores do corpus foram computados de uma vez por todas. É também o que a torna imprecisa, porque o modelo nunca vê a consulta e o documento em conjunto: deve resumir cada texto num vetor sem saber o que lhe será pedido mais tarde.

Um cross-encoder, também chamado reranker, recebe o par (consulta, documento) como entrada e produz uma pontuação de relevância muito mais fina, porque lê ambos os textos em conjunto e consegue detetar que um documento aborda o tema, mas num sentido oposto. Este ganho tem um custo: o modelo deve processar cada documento individualmente, o que proíbe a sua utilização em todo o corpus. A solução é empregá-lo onde é rentável, num pequeno conjunto de candidatos já pré-selecionados.

Daí resulta o pipeline de duas fases, onde cada modelo faz o que sabe fazer de melhor: o rápido reduz o campo de ação, o preciso faz a seleção final.

Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results

Reranking com a Cohere

A Cohere disponibiliza um reranker de alto desempenho via API, o que evita a necessidade de alojar um modelo. A função seguinte encadeia as duas etapas: primeiro recupera vinte candidatos via similaridade de vetores, depois pede ao rerank-v3.5 para manter apenas cinco. Note o campo index_original preservado no resultado: o reranker devolve posições relativas à lista de candidatos, e precisará disto para mapear de volta para o documento real no seu corpus.

import cohere
from openai import OpenAI

co = cohere.Client(api_key="your-cohere-key")
openai_client = OpenAI()

def search_and_rerank(
    question: str,
    documents: list[str],
    embeddings_corpus,
    k_retrieval: int = 20,
    k_final: int = 5
) -> list[dict]:
    """Semantic search + reranking."""
    # Step 1: Fast retrieval (bi-encoder)
    query_emb = openai_client.embeddings.create(
        input=question,
        model="text-embedding-3-large"
    ).data[0].embedding

    import numpy as np
    scores = embeddings_corpus @ np.array(query_emb)
    top_indices = np.argsort(scores)[-k_retrieval:][::-1]
    candidates = [documents[i] for i in top_indices]

    # Step 2: Reranking (cross-encoder)
    rerank_response = co.rerank(
        query=question,
        documents=candidates,
        top_n=k_final,
        model="rerank-v3.5"
    )

    return [
        {
            "text": candidates[r.index],
            "rerank_score": r.relevance_score,
            "original_index": int(top_indices[r.index])
        }
        for r in rerank_response.results
    ]

Reranking com um LLM

Se preferir não adicionar outro fornecedor à sua arquitetura — por razões contratuais, localização de dados ou simplesmente faturação —, um LLM que já utiliza pode assumir esse papel. Submete a pergunta e um documento, solicita uma pontuação de 0 a 10 e ordena os resultados. Definir a temperatura para zero e reduzir max_tokens para cinco garante uma saída determinística e económica; o bloco try/except trata os casos em que o modelo responde com algo que não seja um número.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Uses an LLM to score relevance."""
    scores = []

    for i, doc in enumerate(candidates):
        response = client.chat.completions.create(
            model="gpt-5.6-terra",
            messages=[{
                "role": "user",
                "content": (
                    f"On a scale of 0 to 10, how relevant is this document "
                    f"for answering the question?\n\n"
                    f"Question: {question}\n\n"
                    f"Document: {doc}\n\n"
                    f"Respond only with a number between 0 and 10."
                )
            }],
            temperature=0,
            max_tokens=5
        )
        try:
            score = float(response.choices[0].message.content.strip())
        except ValueError:
            score = 0.0
        scores.append({"index": i, "text": doc, "score": score})

    scores.sort(key=lambda x: x["score"], reverse=True)
    return scores[:k]

Esta versão custa uma chamada por candidato, ou seja, vinte chamadas e tanta latência cumulativa para uma única pergunta do utilizador. Na prática, isto é proibitivo numa interface interativa. Em vez disso, pedimos ao modelo que classifique todos os documentos de uma vez, apresentando cada candidato truncado a 200 caracteres e numerado, esperando apenas uma lista de índices como retorno.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Reranking in a single LLM call."""
    formatted_docs = "\n".join(
        f"[{i}] {doc[:200]}" for i, doc in enumerate(candidates)
    )

    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Rank these documents by relevance to the question. "
                f"Return the indices of the {k} most relevant "
                f"documents, separated by commas, from most to "
                f"least relevant.\n\n"
                f"Question: {question}\n\n"
                f"Documents:\n{formatted_docs}\n\n"
                f"Indices (e.g., 3,1,7,0,5):"
            )
        }],
        temperature=0,
        max_tokens=50
    )

    indices_str = response.choices[0].message.content.strip()
    return [int(i.strip()) for i in indices_str.split(",")][:k]

Integração no Pipeline RAG

Num pipeline completo, o reranking encaixa-se entre a recuperação e a geração sem alterar mais nada. O ponto chave na classe abaixo é o limiar de 0,3 no relevance_score: permite devolver menos de cinco contextos quando nenhum candidato é verdadeiramente relevante, em vez de alimentar o gerador com ruído. Frequentemente, este filtro, mais do que o próprio reranking, elimina respostas alucinadas.

class RAGPipelineWithReranking:
    def __init__(self):
        self.client = OpenAI()
        self.co = cohere.Client()

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Broad retrieval
        candidates = self.search(question, embeddings_corpus, k=20)

        # 2. Reranking
        candidate_docs = [chunks[i]["text"] for i in candidates]
        reranked = self.co.rerank(
            query=question,
            documents=candidate_docs,
            top_n=5,
            model="rerank-v3.5"
        )

        # 3. Select the best
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Relevance threshold
        ]

        # 4. Generate the answer
        return self.generate(question, contexts)

Impacto do Reranking

MétricaSem RerankingCom RerankingGanho
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Estes números dizem exatamente o que um reranker faz. O recall não se move, e isso é lógico: os candidatos são os mesmos, e o cross-encoder não pode resgatar um documento que o bi-encoder não trouxe à superfície. No entanto, a precisão e o MRR melhoram significativamente, porque o documento correto passa do sexto lugar para o primeiro. Corolário prático: se o seu recall for fraco, o reranking não o salvará; deve primeiro alargar a recuperação ou rever a fragmentação.

Pontos-chave

  • O reranking reordena os candidatos com um modelo mais preciso
  • Pipeline típico: bi-encoder (top 20–50) → cross-encoder (top 5)
  • O Cohere rerank-v3.5 é uma solução pronta a usar
  • Um LLM pode servir de reranker se preferir evitar uma dependência externa
  • O ganho de precisão é significativo (tipicamente 20–35%)