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.