Pedro Sousa
‹ ← Artigos

Artigo · Blog

O documento que você indexou não é o documento que o modelo precisa ler

RAG falha silenciosamente quando o pipeline de ingestão trata todos os documentos como se fossem iguais. O problema não está na busca vetorial. Está em o que você decidiu indexar e como estruturou isso antes de qualquer embedding.

O documento que você indexou não é o documento que o modelo precisa ler

Quando montei o primeiro pipeline RAG real de um sistema de produção, o recall estava bom. A busca retornava os chunks certos. O modelo tinha acesso às informações corretas.

E mesmo assim, as respostas estavam erradas.

Não drasticamente erradas. Erradas de um jeito sutil: o modelo usava a informação, mas sem contexto suficiente para aplicá-la bem. Ele sabia o que estava escrito. Não sabia o que aquilo significava dentro do sistema.

Levei um tempo para perceber onde estava o problema.


O pipeline que parecia correto

A arquitetura era a que todo tutorial mostra: você pega os documentos, divide em chunks, gera embeddings, armazena num vector database, e na hora da query faz a busca por similaridade e injeta os resultados no contexto.

Funciona no papel. Funciona em demos. Falha em produção de um jeito específico que é difícil de diagnosticar porque os componentes individuais estão todos operacionais.

O problema está numa premissa implícita que você provavelmente aceitou sem questionar: que o documento que existe no seu sistema é o documento que o modelo precisa ler.

Não é.


O que o documento original carrega

Documentos internos de um sistema real carregam muito contexto implícito.

Uma especificação técnica escrita para engenheiros assume que quem lê conhece o histórico do projeto, as decisões que vieram antes, as siglas internas, o que foi descartado e por quê. Um PDF de política de uso escrito pelo jurídico assume que quem lê conhece a regulamentação de fundo. Um changelog assume que quem lê acompanhou a versão anterior.

Quando você fatia esse documento em chunks e indexa, você perde grande parte desse contexto implícito. O chunk retornado pela busca vetorial existe no vácuo. Ele tem as palavras certas. Não tem o contexto que torna essas palavras compreensíveis.

O modelo lê o chunk. Não lê o que estava na cabeça de quem escreveu o documento.


O problema que a maioria ignora: ingestão é modelagem

Existe uma etapa que a maioria das implementações de RAG trata como operacional e deveria tratar como arquitetural: a transformação do documento antes do embedding.

Não estou falando de chunking strategy. Chunk size, overlap, separadores, tudo isso importa. Mas importa menos do que a decisão anterior: o que você decide que o chunk precisa conter para ser útil isoladamente.

Num sistema de suporte que montei, o problema apareceu assim: a busca retornava o chunk correto sobre uma regra de negócio, mas o chunk não dizia em qual contexto aquela regra se aplicava. O modelo gerava uma resposta tecnicamente correta mas aplicada ao caso errado.

A solução não foi melhorar a busca. Foi mudar o que o chunk continha.

Cada chunk passou a incluir metadados explícitos no próprio texto: o escopo do documento de origem, o tipo de conteúdo, as pré-condições que se aplicavam àquela seção. Não só como metadados de filtro no banco vetorial. Dentro do texto que o modelo leria.

Isso é o que chamo de contextualização de ingestão: tratar a etapa de preparação dos documentos como modelagem de domínio, não como transformação técnica.


Onde MCP muda o problema

Model Context Protocol resolve um problema diferente, mas relacionado.

RAG pressupõe que você consegue antecipar o que o modelo vai precisar e pré-indexar isso. Para muitos casos, essa premissa vale. Para sistemas dinâmicos, ela falha.

Quando o modelo precisa de informação que muda constantemente, ou precisa navegar por uma estrutura que depende do estado atual do sistema, RAG estático não é a ferramenta certa. Você indexa um snapshot. O sistema mudou.

MCP resolve isso expondo ferramentas que o modelo pode chamar em tempo real. Em vez de buscar num índice estático, o modelo consulta o sistema diretamente quando precisa.

O erro que tenho visto é tratar MCP como substituto de RAG. Não é. São camadas diferentes.

RAG é memória de longo prazo sobre conhecimento estável. MCP é acesso operacional a sistemas dinâmicos. Misturar os casos de uso é o que gera pipelines confusos onde o modelo ora busca no índice, ora chama uma ferramenta, sem critério claro, e as respostas ficam inconsistentes dependendo de qual caminho foi ativado.


A decisão que a maioria não toma

O que falta na maioria das implementações não é tecnologia. É uma decisão explícita sobre qual tipo de conhecimento cada mecanismo deve servir.

Conhecimento estável de domínio, documentação, políticas, especificações que mudam raramente: RAG, com ingestão cuidadosa e contextualização explícita dos chunks.

Estado atual do sistema, dados de usuário, informação que muda durante a sessão: ferramentas via MCP ou function calling, chamadas em tempo real.

Conhecimento que o modelo precisa para raciocinar bem sobre o domínio antes de qualquer query: prompt de sistema, não RAG, não MCP.

Quando você não toma essa decisão, o sistema tenta resolver tudo com um mecanismo só. E falha em borda de caso o tempo inteiro, porque cada mecanismo tem características diferentes de latência, coerência e freshness.


O que eu faria diferente

No primeiro pipeline que montei, tratei a ingestão como infraestrutura. Escolhi o chunker, configurei o tamanho, rodei o embedding, subi pro banco. Pronto.

Hoje eu trato a ingestão como a etapa mais importante do pipeline RAG, não como a mais mecânica.

Antes de indexar qualquer documento, a pergunta que faço é: se eu pegar esse chunk isolado e mostrar para alguém que não conhece o sistema, ele vai entender o que esse trecho significa e onde se aplica? Se a resposta for não, o chunk não está pronto para ser indexado.

Isso implica transformação real antes do embedding: adicionar contexto explícito, normalizar terminologia interna, desambiguar referências que dependem de conhecimento implícito, às vezes reescrever seções inteiras para que façam sentido fora do documento original.

É trabalho. É mais trabalho do que configurar parâmetros de chunking.

E é a diferença entre um pipeline RAG que funciona em demo e um que funciona em produção.


A ilusão do recall alto

Existe uma métrica que engana muito no desenvolvimento de sistemas RAG: recall da busca.

Você mede se os chunks certos estão sendo retornados. O recall está em 90%. Parece bom.

Mas recall mede se o chunk correto foi recuperado. Não mede se o chunk continha informação suficiente para o modelo responder bem. São métricas de problemas diferentes.

Você pode ter recall perfeito e qualidade de resposta ruim, se o chunk certo estava mal contextualizado.

O problema não estava no seu vector database. Estava no que você decidiu colocar dentro dele.

Essa é a parte contraintuitiva: otimizar embedding e busca é o trabalho visível. Preparar os documentos para que sejam compreensíveis fora do seu contexto original é o trabalho invisível que determina se o sistema funciona.

A maioria investe no primeiro e subestima o segundo.