Pedro Sousa
‹ ← Artigos

Artigo · Blog

O embedding que você gerou não representa o que o modelo vai ler

A maioria dos sistemas RAG falha antes da busca. O problema está em como o conteúdo foi transformado em vetor, não em como ele foi recuperado. Indexar o texto errado é um erro silencioso que só aparece na resposta final.

O embedding que você gerou não representa o que o modelo vai ler

Passei alguns meses construindo um sistema de recuperação de contexto para um produto que usava documentação técnica como base de conhecimento. A busca funcionava. Os chunks voltavam. O modelo respondia.

Só que as respostas estavam erradas com frequência suficiente para ser um problema real, não um caso de borda.

Eu olhava para os chunks recuperados e eles pareciam relevantes. Olhava para a query e ela era clara. O modelo era capaz. Mas a resposta final vivia num espaço entre o que foi perguntado e o que estava na documentação, sem chegar em nenhum dos dois.

Levei mais tempo do que deveria para identificar onde estava o erro.


O problema não estava na busca

A intuição inicial de quem depura um sistema RAG é ajustar a busca. Mudar a função de similaridade. Aumentar o top-k. Testar MMR em vez de similaridade pura. Reclassificar os resultados.

Fiz tudo isso. Melhorou marginalmente. O problema continuava.

O erro estava antes. Estava no momento em que o conteúdo foi transformado em vetor.

O embedding captura semântica. Mas semântica de quê, exatamente? Do texto que você passou para a função de embedding. E esse texto raramente é o mesmo que o modelo vai precisar ler para responder a pergunta.

Isso parece óbvio escrito assim. Não é óbvio quando você está no meio do pipeline.


O que a maioria indexa e o que o modelo precisa

Num sistema de documentação técnica, o erro mais comum que cometi, e que vi repetido em outros projetos, é indexar blocos de texto contínuo extraídos diretamente do documento.

O problema é que documentação técnica foi escrita para ser lida com contexto. Um parágrafo explicando um comportamento assume que você leu o título da seção, o subtítulo, o parágrafo anterior. Quando você pega esse parágrafo isolado e gera um embedding, o vetor representa um fragmento que, fora do contexto original, significa outra coisa.

A busca vai recuperar esse chunk porque ele é semanticamente próximo da query. Mas o modelo vai receber um texto que começa no meio de um raciocínio, sem saber onde está na estrutura do documento, sem o título que qualifica o que está sendo explicado.

A resposta do modelo vai ser boa o suficiente para parecer correta, e errada o suficiente para gerar problema em produção.


A assimetria que você está ignorando

Existe uma assimetria fundamental em sistemas RAG que a maioria não trata explicitamente: o embedding é gerado uma vez, na indexação. A query é gerada no momento da busca. E o texto que o modelo vai ler é o chunk original, não a representação vetorial dele.

Essas três coisas precisam estar alinhadas. Raramente estão.

A query chega em linguagem natural, geralmente como uma pergunta. O embedding do chunk foi gerado a partir de texto afirmativo, talvez técnico, talvez fragmentado. A similaridade vetorial aproxima os dois, mas não garante que o modelo vai conseguir usar o chunk para responder a pergunta.

O vetor diz que o chunk é relevante. O modelo ainda precisa conseguir lê-lo.


O que funcionou melhor na prática

A mudança que mais impactou a qualidade das respostas não foi na busca. Foi na preparação do conteúdo antes da indexação.

Duas coisas fizeram diferença real.

A primeira foi enriquecer o chunk com contexto estrutural antes de gerar o embedding. Em vez de indexar o parágrafo isolado, eu concatenava o título da seção, o subtítulo e os primeiros tokens do parágrafo anterior como prefixo. O texto que ia para a função de embedding tinha contexto suficiente para representar o que o chunk significava dentro do documento. O texto que ia para o modelo era o chunk original, sem o prefixo.

Isso resolve parcialmente o problema. O vetor agora representa um fragmento contextualizado. A busca passa a recuperar chunks que fazem mais sentido.

A segunda mudança foi gerar embeddings a partir de perguntas hipotéticas, não do texto em si. Para cada chunk relevante, eu gerava automaticamente três ou quatro perguntas que aquele chunk responderia, e indexava essas perguntas com referência ao chunk. Na busca, a query do usuário era comparada com perguntas hipotéticas, não com texto afirmativo. A similaridade aumentou de forma mensurável.

Isso tem um custo. Indexação mais lenta, mais tokens gastos, pipeline mais complexo. Em produção, vale a pena se a qualidade das respostas for crítica.


O erro que MCP não resolve

Depois de trabalhar com MCP em alguns contextos, percebi que o problema do embedding mal gerado reaparece de outra forma quando você conecta ferramentas de recuperação como recursos MCP.

O MCP resolve a fronteira entre o agente e o sistema externo. Ele define quando e como o modelo acessa informação. Mas ele não resolve o que está dentro do sistema externo.

Se o seu servidor MCP expõe uma ferramenta de busca que por baixo usa um índice vetorial com embeddings ruins, o agente vai recuperar contexto ruim com mais eficiência. O MCP vai funcionar perfeitamente. As respostas vão continuar sendo ruins.

A camada de integração está certa. A camada de representação está errada. E isso é difícil de depurar porque tudo no pipeline parece funcionar.


Trade-offs honestos

Enriquecer chunks com contexto estrutural aumenta o tamanho dos documentos indexados. Dependendo do volume, isso impacta custo de armazenamento e latência de busca.

Gerar perguntas hipotéticas aumenta o custo de indexação de forma significativa. Num corpus grande, isso pode ser proibitivo sem uma estratégia de indexação incremental.

E existe um problema mais sutil: o contexto que você adiciona ao chunk para melhorar o embedding pode introduzir ruído se o documento for mal estruturado. Documentação inconsistente, títulos genéricos, seções sem hierarquia clara. Nesses casos, o prefixo de contexto pode fazer o embedding representar algo errado com ainda mais confiança.


O que eu faria diferente hoje

Eu começaria avaliando a qualidade dos embeddings antes de construir qualquer coisa de busca.

Pega um conjunto de perguntas reais que o sistema deveria responder. Recupera os chunks. Avalia manualmente se os chunks recuperados são os que você esperaria. Se a precisão estiver ruim nessa etapa, nenhum ajuste posterior vai resolver.

E trocaria a métrica de sucesso. Em vez de medir precisão da busca isolada, mediria a qualidade da resposta final por tipo de pergunta. É a única métrica que importa em produção.


A parte contraintuitiva de sistemas RAG é que a etapa mais invisível, a geração do embedding, é a que mais determina a qualidade do sistema inteiro. Você pode ter o melhor modelo disponível, um pipeline de busca bem calibrado, um servidor MCP correto, e ainda assim entregar respostas ruins se o vetor não representar o que o modelo vai precisar ler.

O problema não aparece nos logs. Aparece na resposta que o usuário recebe.