Geração Aumentada por Busca (RAG)

Intenção

Antes de responder, o sistema busca os trechos mais relevantes da sua base de conhecimento e entrega ao modelo junto com a pergunta, pedindo que ele responda só com base neles. RAG (geração aumentada por busca) serve para assistentes que precisam responder sobre documentos seus, que o modelo nunca viu ou que mudam com frequência.

Problema

O time de RH da empresa da Lúcia lançou um assistente para tirar dúvidas dos funcionários. Ele respondia com muita confiança sobre férias, reembolso e home office. O problema: respondia com base no que o modelo “sabia” em geral, e não na política da empresa.

Um funcionário perguntou quantos dias de home office podia fazer por semana. O bot disse três, que é comum no mercado. A política da empresa dizia dois. A política tinha mudado em março, e o modelo nem conhecia a versão antiga.

A primeira tentativa foi colar o manual inteiro no system prompt. Funcionou por um tempo, até o manual chegar a 300 páginas. Cada pergunta ficou lenta e cara, e o bot começou a misturar a regra de reembolso com a de viagem.

Esse erro tem consequência fora do time de TI. Em Moffatt v. Air Canada (2024), o chatbot da companhia aérea disse a um cliente que ele podia pedir a tarifa de luto depois da viagem. A política publicada no site dizia outra coisa. O tribunal de pequenas causas da Colúmbia Britânica decidiu que a empresa responde pelo que o bot diz e mandou pagar a diferença.

A pergunta que este padrão responde: como fazer o modelo responder com a informação certa e atual, sem mandar tudo em toda chamada?

Solução

Separe o conhecimento do modelo. Os documentos ficam num índice de busca, quebrados em pedaços (chunks). A cada pergunta, o sistema busca os poucos pedaços mais relevantes e monta a entrada do modelo com eles, marcados com identificadores.

O prompt pede três coisas: responder só com base nos trechos, citar de onde veio cada afirmação e dizer “não encontrei” quando a resposta não está ali. A busca decide o que o modelo lê; o modelo decide como responder.

Atualizar o conhecimento passa a ser atualizar o índice, sem mexer no prompt. Quando a política de home office mudar de novo, alguém reindexa o documento e a próxima resposta já sai certa.

O nome vem do artigo de Lewis et al. (2020), que juntou um buscador a um gerador de texto. A versão que você vai montar hoje é mais simples: um índice comum, um modelo de mercado e um prompt bem escrito.

Estrutura

flowchart LR
  Q(["1. Pergunta"]):::io --> S["2. Buscar trechos"]:::tool
  IDX[("Índice de documentos")]:::store --> S
  S --> C["3. Montar contexto com IDs"]:::tool
  C --> M(["4. Responder com citações"]):::llm
  M --> V{"5. Citou trechos válidos?"}
  V -->|"sim"| OUT(["6. Resposta com fontes"]):::io
  V -->|"não"| N(["6. Não encontrei"]):::io

1. A pergunta chega do usuário.
2. A busca procura no índice os pedaços mais parecidos com a pergunta, por embedding, palavra-chave ou os dois.
3. O código monta o contexto: cada trecho com um ID e a fonte.
4. O modelo responde só com base nos trechos e cita os IDs que usou.
5. O código confere se os IDs citados existem no contexto enviado.
6. A resposta sai com as fontes, ou com um “não encontrei” honesto.

O índice é montado antes, num processo separado: carregar documentos, quebrar em pedaços, gerar embeddings e gravar. Esse processo roda de novo sempre que um documento muda.

Exemplo trabalhado

Acompanhe a pergunta do funcionário do começo ao fim. Ela chega assim: “Quantos dias de home office posso fazer por semana?”.

A busca devolve os cinco pedaços mais próximos. Os três primeiros, com a pontuação de similaridade:

politica-remoto#2   0.82  "A partir de março de 2026, o trabalho remoto é de até dois dias por semana..."
politica-remoto#1   0.74  "Esta política vale para funcionários CLT de todas as áreas..."
beneficios#7        0.61  "O auxílio home office é de R$ 120 por mês, pago na folha..."

O código monta o contexto com os IDs entre colchetes e envia ao modelo. A resposta volta estruturada:

{ "text": "Você pode fazer até dois dias de home office por semana, regra que vale desde março de 2026.", "sources": ["politica-remoto#2"], "found": true }

O código confere que politica-remoto#2 estava entre os IDs enviados. Estava, então a resposta sai com um link para a seção 2 da política.

Agora a conta de tokens, com números ilustrativos. Suponha 500 tokens por página do manual: as 300 páginas somam 150 mil tokens em toda chamada. Com RAG, cinco pedaços de 400 tokens somam 2 mil tokens de contexto. Em mil perguntas por dia, a diferença é de 150 milhões para 2 milhões de tokens de entrada.

Pseudocódigo

schema Answer { text: string, sources: list of string, found: bool }

function ask(question):
    # 2. buscar só o que importa
    chunks = index.search(question, k=5)
    trace.span("retrieve", chunks.ids, chunks.scores)

    # 3. contexto com identificadores
    context = join(f"[{c.id}] ({c.source}) {c.text}" for c in chunks)

    # 4. responder só com base nos trechos
    answer = llm(RAG_PROMPT, { context, question }) -> Answer

    # 5. conferir as citações no código
    if not answer.found or not answer.sources ⊆ chunks.ids:
        return "Não encontrei isso nos documentos."
    return answer

Cenários reais

• Chat com a base de conhecimento interna. Políticas, processos e documentação técnica num índice só. As citações viram links para o documento original, e o funcionário confere a regra na fonte.
• Bot de suporte com escalonamento humano. O bot busca nos artigos da central de ajuda antes de responder. Quando nenhum trecho é relevante, a conversa vai para uma pessoa em vez de virar invenção.
• Assistente de saúde com guardrails. A base é restrita a conteúdo aprovado por profissionais. O “não encontrei” é parte da segurança: fora da base, o assistente orienta procurar atendimento.
• Assistente jurídico. Em Mata v. Avianca (2023), advogados nos Estados Unidos protocolaram uma petição com decisões inventadas pelo ChatGPT e foram multados. Um assistente jurídico com RAG só cita decisões que estão no índice, e o código confere cada citação antes de a resposta sair.

Aplicabilidade

• O conhecimento necessário é seu: políticas, manuais, contratos, tickets, código.
• O conteúdo muda e você precisa que a resposta acompanhe a versão atual.
• A base é grande demais para caber, inteira, em toda chamada.
• Você precisa mostrar de onde veio a resposta.

Quando não usar

• A base cabe confortavelmente no contexto. Mandar tudo, com cache de prompt, é mais simples e evita erro de busca. Veja o smell RAG Desnecessário e a refatoração Trocar RAG por Contexto Direto.
• A pergunta pede um dado exato de um sistema (saldo, status de pedido, data de vencimento de um boleto). Isso é uma consulta, e o caminho é Uso de Ferramentas.
• A pergunta exige raciocinar sobre a base inteira (“quantos contratos vencem este ano?”). Busca por similaridade traz alguns trechos, não todos. O caminho é consulta estruturada, como no cenário Perguntas em linguagem natural para SQL, ou processamento em lote com Map-Reduce.

Como implementar

1. Junte as perguntas reais que o assistente vai receber. Elas guiam todo o resto.
2. Escolha as fontes e limpe os documentos: tire menus, rodapés e duplicatas.
3. Quebre em pedaços por estrutura (seção, artigo, cláusula), não por número fixo de caracteres. Guarde título, fonte e data de vigência junto de cada pedaço.
4. Gere embeddings e grave num índice. Comece simples: um banco com extensão de vetor resolve muitos casos.
5. Meça a busca sozinha antes de ligar o modelo: para cada pergunta, o trecho certo está entre os primeiros?
6. Escreva o prompt com as três regras: só os trechos, citar IDs, admitir quando não encontrou.
7. Confira as citações no código e trate o “não encontrei” como resposta válida.
8. Monte o processo de atualização do índice e registre a versão do índice em cada trace.

Erros comuns de quem está começando

• Cortar a cada 1.000 caracteres. A regra “até dois dias por semana” cai metade num pedaço e metade no outro. Nenhum dos dois responde a pergunta sozinho.
• Pedaço sem cabeçalho. O trecho “o limite é de dois dias” não diz de que política é. Junte o título da seção ao texto, ou veja Chunking com Contexto.
• Duas versões da mesma política no índice. A versão de 2024 e a de 2026 competem na busca. Marque a vigência e filtre os documentos revogados.
• Ajustar o prompt quando o erro é de busca. Se o trecho certo não chegou, nenhuma instrução salva a resposta. Olhe primeiro os IDs recuperados no trace.

Variações

• Busca Híbrida. Junta embedding e palavra-chave. Ajuda com siglas, códigos e nomes próprios.
• Reordenação. Busca muitos candidatos e usa um modelo para reordenar (reranking) e ficar com os melhores.
• Reescrita de Consulta. Reescreve a pergunta antes de buscar, útil em conversas em que “e para estagiário?” depende do contexto.
• RAG Agêntico. Um agente decide quando buscar, o que buscar e se precisa buscar de novo.
• Ancoragem com Citação. Exige que cada afirmação aponte o trecho exato que a sustenta, frase por frase.

Custo, latência e falhas

Um detalhe sobre k: mais trechos não é sempre melhor. O estudo “Lost in the Middle” (Liu et al., 2023) mostrou que modelos usam pior a informação que fica no meio de um contexto longo. Prefira poucos trechos bons a muitos trechos médios.

Como avaliar

Avalie a busca e a resposta separadas. A maioria dos problemas de RAG é problema de busca.

• Busca: para cada pergunta, o trecho certo apareceu entre os k primeiros? (recall@k)
• Fidelidade: cada afirmação da resposta está sustentada por um trecho citado?
• Abstenção: em perguntas sem resposta na base, o sistema diz “não encontrei”?
• Utilidade: a resposta resolve a dúvida de quem perguntou?

Um caso de eval:

{ "question": "Quantos dias de home office posso fazer por semana?", "expected_chunk": "politica-remoto#2", "expected_answer_contains": "dois dias" }

Inclua perguntas sem resposta na base, como “a empresa paga academia?” quando nenhuma política fala disso. Elas medem se o sistema sabe dizer que não sabe. Para montar o conjunto, veja Dataset de Ouro.

A separação ajuda no diagnóstico. Se o recall@5 é 95% e a resposta erra, o problema está no prompt ou no modelo. Se o recall@5 é 60%, mexer no prompt não adianta.

Em produção

• Span retrieve com IDs, pontuações e a versão do índice.
• Taxa de “não encontrei” por dia. Subiu de repente: pode ser assunto novo ou índice quebrado.
• Lista das perguntas com pontuação de busca baixa, para descobrir documentos que faltam.
• Retorno do usuário (útil ou não) ligado aos trechos citados, para achar documentos ruins.

Segurança

Todo documento indexado vira texto que o modelo lê. Se alguém consegue colocar um documento na base, consegue colocar instruções na frente do modelo. Greshake et al. (2023) mostraram essa injeção indireta em sistemas reais: a instrução maliciosa estava no conteúdo buscado, não na mensagem do usuário.

Três cuidados:

• Controle quem escreve no índice. Uma wiki aberta a qualquer funcionário é uma porta de entrada.
• Respeite permissões na hora da busca. O estagiário não pode receber trechos da pasta da diretoria. Filtre antes de buscar, não depois de responder.
• Trate trecho buscado como dado. Leia o smell Ordem Vinda do Dado e o fundamento Prompt injection na prática.

Na versão brasileira do problema, a LGPD também entra: indexar tickets de clientes leva dados pessoais para o índice. Decida o que entra, por quanto tempo fica e quem pode recuperar.

Prós e contras

Código

As abas fazem a mesma coisa: buscar trechos, montar o contexto com IDs, pedir resposta estruturada com fontes e conferir as citações. Python e TypeScript chamam a Anthropic. LangChain troca o modelo da resposta. A busca continua sua: é ela que decide o que o modelo pode citar.

import anthropic
from pydantic import BaseModel
from sentence_transformers import SentenceTransformer, util

client = anthropic.Anthropic()
embedder = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")

# índice montado antes: cada pedaço com id, fonte e texto
CHUNKS = load_chunks("politicas/")  # sua função de carga e chunking
VECTORS = embedder.encode([c["text"] for c in CHUNKS])

RAG_PROMPT = """Responda à pergunta usando apenas os trechos fornecidos.
Cite em sources os IDs dos trechos usados.
Se a resposta não estiver nos trechos, use found=false e não invente."""


class Answer(BaseModel):
    text: str
    sources: list[str]
    found: bool


def ask(question: str, k: int = 5) -> Answer | None:
    # 2. buscar os k pedaços mais próximos
    scores = util.cos_sim(embedder.encode(question), VECTORS)[0]
    top = [CHUNKS[i] for i in scores.argsort(descending=True)[:k].tolist()]

    # 3. contexto com identificadores
    context = "\n\n".join(f"[{c['id']}] ({c['source']})\n{c['text']}" for c in top)

    # 4. responder só com base nos trechos
    answer = client.messages.parse(
        model="claude-opus-5-5",
        max_tokens=2048,
        system=RAG_PROMPT,
        messages=[{"role": "user", "content": f"<trechos>\n{context}\n</trechos>\n\nPergunta: {question}"}],
        output_format=Answer,
    ).parsed_output

    # 5. conferir as citações no código
    ids = {c["id"] for c in top}
    if not answer.found or not answer.sources or not set(answer.sources) <= ids:
        return None  # 6. "não encontrei"
    return answer

import Anthropic from "@anthropic-ai/sdk";
import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";
import { z } from "zod";

const client = new Anthropic();

const RAG_PROMPT = `Responda à pergunta usando apenas os trechos fornecidos.
Cite em sources os IDs dos trechos usados.
Se a resposta não estiver nos trechos, use found=false e não invente.`;

const Answer = z.object({ text: z.string(), sources: z.array(z.string()), found: z.boolean() });

// search é a consulta ao seu banco vetorial: devolve { id, source, text }[]
export async function ask(question: string, k = 5) {
  // 2. buscar os k pedaços mais próximos
  const top = await search(question, k);

  // 3. contexto com identificadores
  const context = top.map((c) => `[${c.id}] (${c.source})\n${c.text}`).join("\n\n");

  // 4. responder só com base nos trechos
  const { parsed_output: answer } = await client.messages.parse({
    model: "claude-opus-5-5",
    max_tokens: 2048,
    system: RAG_PROMPT,
    messages: [{ role: "user", content: `<trechos>\n${context}\n</trechos>\n\nPergunta: ${question}` }],
    output_config: { format: zodOutputFormat(Answer) },
  });

  // 5. conferir as citações no código
  const ids = new Set(top.map((c) => c.id));
  if (!answer?.found || answer.sources.length === 0 || !answer.sources.every((s) => ids.has(s))) {
    return null; // 6. "não encontrei"
  }
  return answer;
}

from langchain.chat_models import init_chat_model
from pydantic import BaseModel

class Answer(BaseModel):
    text: str
    sources: list[str]
    found: bool

RAG_PROMPT = """Responda à pergunta usando apenas os trechos fornecidos.
Cite em sources os IDs dos trechos usados.
Se a resposta não estiver nos trechos, use found=false e não invente."""

# "provedor:modelo". A busca não entra nessa string.
answerer = init_chat_model("openai:gpt-4o-mini", temperature=0).with_structured_output(Answer)


def ask(question: str, k: int = 5) -> Answer | None:
    top = search(question, k)  # 2. embedding, palavra-chave ou os dois

    # 3. contexto com identificadores
    context = "\n\n".join(f"[{c['id']}] ({c['source']})\n{c['text']}" for c in top)

    # 4. responder só com base nos trechos
    answer = answerer.invoke([
        ("system", RAG_PROMPT),
        ("human", f"<trechos>\n{context}\n</trechos>\n\nPergunta: {question}"),
    ])

    # 5. conferir as citações no código
    ids = {c["id"] for c in top}
    if not answer.found or not answer.sources or any(s not in ids for s in answer.sources):
        return None  # 6. "não encontrei"
    return answer

Suporte por framework

Conferido na documentação do LangChain 1.x em outubro de 2026.

Teste seu entendimento