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

RAG Adaptativo

Aula 17 de 18 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Encaminhamento inteligente de perguntas
  2. Implementar o roteador
  3. O pipeline completo
  4. Pontos-chave

Encaminhamento inteligente de perguntas

O Self-RAG aplica o mesmo tratamento a todas as perguntas, e é exatamente aí que reside a sua falha. Pergunte-lhe quanto é dois mais dois: ele irá codificar a consulta, vasculhar o índice, classificar quatro documentos irrelevantes, mudar para a web, gerar e verificar. São uma dúzia de chamadas ao LLM para uma pergunta que o modelo resolve instantaneamente. Nem todas as perguntas têm a mesma complexidade, e uma questão factual simples não exige o mesmo tratamento que uma que exija síntese através de múltiplos documentos. O RAG Adaptativo adiciona, portanto, um roteador inteligente a montante do pipeline: analisa a pergunta e seleciona a estratégia ótima antes de iniciar qualquer processamento dispendioso.

O roteador tem três destinos. As perguntas sobre tópicos efetivamente cobertos pelos seus documentos vão para a loja vetorial; este é o caminho RAG completo. As perguntas sobre atualidades ou fora do âmbito indexado vão para a pesquisa na web, uma vez que consultar o índice apenas devolveria ruído. Por fim, as perguntas simples ou de cultura geral recebem uma resposta direta do modelo, sem qualquer recuperação.

Implementar o roteador

A parte delicada é que o roteador deve conhecer o âmbito do seu índice para tomar uma decisão. A solução escolhida é tão simples quanto eficaz: passar-lhe a lista de tópicos cobertos, indexed_topics, que ele compara com a pergunta. As três regras são declaradas explicitamente no prompt, e o formato JSON restrito garante um valor utilizável. O result.get("route", "vectorstore") merece atenção: em caso de resultado inesperado, o padrão recua para a loja vetorial. Este é o comportamento mais seguro, confiando nos seus dados em vez da web ou da memória do modelo.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def route_question(question, indexed_topics):
    """Encaminha uma pergunta para a melhor estratégia."""
    topics_str = ", ".join(indexed_topics)

    prompt = f"""You are a question router. Given a question,
determine the best source of information.

Your indexed documents cover the following topics: {topics_str}

Rules:
- If the question concerns indexed topics -> "vectorstore"
- If the question concerns current events or an uncovered topic -> "websearch"
- If the question is very simple or general knowledge -> "direct"

Respond ONLY with a JSON object: {{"route": "vectorstore"}} or {{"route": "websearch"}} or {{"route": "direct"}}

Question: {question}

Route JSON:"""

    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
        response_format={"type": "json_object"},
    )

    result = json.loads(response.choices[0].message.content)
    return result.get("route", "vectorstore")

# Testar o roteador
topics = ["embeddings", "RAG", "Mistral AI", "vector search", "FAISS"]

tests = [
    "How does mistral-embed work?",          # -> vectorstore
    "What is Apple's stock price today?",  # -> websearch
    "How much is 2 + 2?",                        # -> direct
    "What are the steps of RAG?",             # -> vectorstore
    "Who won the 2026 World Cup?",         # -> websearch
]

for q in tests:
    route = route_question(q, topics)
    print(f"  [{route:12s}] {q}")

O conjunto de testes ilustra cada cenário e servirá como a sua salvaguarda. Uma pergunta sobre o mistral-embed enquadra-se perfeitamente nos tópicos declarados, por isso vai para a loja vetorial. Os preços das ações ou os resultados de competições mudam diariamente: nenhum índice estático os pode conter, por isso vão para a web. Dois mais dois não requer nem um corpus nem pesquisa. Reutilize este bloco com os seus próprios tópicos e cerca de quinze perguntas representativas do seu tráfego real: esta é a forma mais económica de verificar se a lista topics é suficientemente precisa. Um roteador que envia tudo para a loja vetorial não agrega valor, e um roteador que responde diretamente sobre os seus tópicos de negócio é francamente perigoso.

O pipeline completo

O AdaptiveRAG reúne tudo o que construiu nas últimas três lições. Cada rota tem o seu próprio método de execução, e o método ask lê-se como uma instrução switch. A rota direct retorna imediatamente, com uma temperatura de 0,3, uma vez que não há contexto a respeitar, e uma lista de fontes vazia que sinaliza honestamente ao utilizador que nada sustenta esta resposta. A rota websearch gera apenas a partir de resultados da web. A rota vectorstore, no entanto, desfruta de toda a artilharia: classificação de documentos ao estilo do Corrective RAG, recurso à web se nenhum sobreviver, e depois um ciclo de geração com verificações de fundamentação e utilidade herdadas do Self-RAG, agrupadas aqui em grade_and_correct.

Uma diferença de limiar vale a pena notar em comparação com a lição sobre Corrective RAG. O recurso à web já não é acionado assim que um documento é descartado, mas apenas se relevant_docs estiver vazio. Esta escolha é mais tolerante: quando dois de quatro fragmentos permanecem relevantes, é razoável gerar com eles em vez de ir para a web, o que poupa uma chamada e reduz a latência. Deve arbitrar com base nos requisitos do seu domínio.

import numpy as np

class AdaptiveRAG:
    """Pipeline RAG Adaptativo com roteamento inteligente."""

    def __init__(self, chunks, embeddings, index, topics):
        self.chunks = chunks
        self.embeddings = embeddings
        self.index = index
        self.topics = topics

    def route(self, question):
        """Determina a estratégia ótima."""
        return route_question(question, self.topics)

    def retrieve_from_vectorstore(self, question, k=4):
        """Recuperação da loja vetorial local."""
        response = client.embeddings.create(
            model="mistral-embed", inputs=[question]
        )
        query_vec = np.array([response.data[0].embedding], dtype=np.float32)
        distances, indices = self.index.search(query_vec, k)

        return [
            {"text": self.chunks[idx]["text"], "source": "vectorstore"}
            for dist, idx in zip(distances[0], indices[0]) if idx >= 0
        ]

    def search_web(self, question):
        """Pesquisa na web para perguntas fora do âmbito."""
        return web_search_fallback(question)

    def direct_answer(self, question):
        """Resposta direta sem recuperação."""
        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[{"role": "user", "content": question}],
            temperature=0.3,
        )
        return response.choices[0].message.content

    def generate_with_context(self, question, documents):
        """Geração com contexto (RAG clássico)."""
        context = "\n\n---\n\n".join([d["text"] for d in documents])
        prompt = f"Context:\n{context}\n\nQuestion: {question}"

        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[
                {"role": "system", "content": "Answer based on the provided context."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.1,
        )
        return response.choices[0].message.content

    def grade_and_correct(self, question, documents, generation):
        """Verificações do Self-RAG (alucinações + utilidade)."""
        is_grounded = check_hallucination(documents, generation)
        if not is_grounded:
            return None, "hallucination"

        is_useful = check_answer_usefulness(question, generation)
        if not is_useful:
            return None, "not_useful"

        return generation, "ok"

    def ask(self, question, max_retries=2):
        """Pipeline RAG Adaptativo completo."""
        print(f"\n{'='*60}")
        print(f"Question: {question}")

        # 1. Roteamento
        route = self.route(question)
        print(f"Chosen route: {route}")

        # 2. Executar com base na rota
        if route == "direct":
            answer = self.direct_answer(question)
            return {"answer": answer, "route": "direct", "sources": []}

        elif route == "websearch":
            docs = self.search_web(question)
            answer = self.generate_with_context(question, docs)
            return {"answer": answer, "route": "websearch", "sources": ["web"]}

        else:  # vectorstore
            docs = self.retrieve_from_vectorstore(question)

            # Classificação de documentos
            relevant_docs = []
            for doc in docs:
                if grade_document(question, doc["text"]):
                    relevant_docs.append(doc)

            # Recurso à web se não houver documentos relevantes suficientes
            if not relevant_docs:
                print("  No relevant documents, web fallback...")
                relevant_docs = self.search_web(question)

            # Ciclo de geração com verificação
            for attempt in range(max_retries + 1):
                generation = self.generate_with_context(question, relevant_docs)
                answer, status = self.grade_and_correct(
                    question, relevant_docs, generation
                )

                if status == "ok":
                    return {
                        "answer": answer,
                        "route": "vectorstore",
                        "attempts": attempt + 1,
                        "sources": [d.get("source", "") for d in relevant_docs],
                    }
                elif status == "not_useful":
                    web_docs = self.search_web(question)
                    relevant_docs.extend(web_docs)

            # Retornar a última geração mesmo que imperfeita
            return {
                "answer": generation,
                "route": "vectorstore",
                "attempts": max_retries + 1,
                "sources": [d.get("source", "") for d in relevant_docs],
            }

# Utilização
adaptive_rag = AdaptiveRAG(chunks, embeddings, index, topics=topics)

questions = [
    "How do I create a FAISS index with mistral-embed?",
    "What is the weather in Paris tomorrow?",
    "How many dimensions does codestral-embed have?",
]

for q in questions:
    result = adaptive_rag.ask(q)
    print(f"\nRoute: {result['route']}")
    print(f"Answer: {result['answer'][:200]}...")

As três perguntas de exemplo percorrem todos os caminhos numa única execução, e o campo route no resultado indica qual foi utilizado. Este é o valor que deve registar em produção: a distribuição das rotas no seu tráfego real é o melhor indicador de saúde do seu sistema, revelando tanto um índice demasiado restrito como um roteador mal calibrado.

Pontos-chave

  • O RAG Adaptativo encaminha cada pergunta para a estratégia ótima (loja vetorial, web, direta)
  • O roteador utiliza um LLM com saída estruturada para classificar as perguntas
  • As perguntas sobre tópicos indexados vão para a loja vetorial; as restantes vão para a web
  • O roteamento reduz a latência e os custos, evitando o RAG completo para perguntas simples
  • O RAG Adaptativo combina ideias do Corrective RAG e do Self-RAG com roteamento