Além do RAG ingênuo
Conheça as limitações da recuperação básica.
Além do RAG ingênuo é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.
O que o RAG ingênuo faz
RAG ingênuo é a linha de base: fragmentar documentos, vetorizá-los, armazenar os vetores, vetorizar a consulta, recuperar os k primeiros por similaridade de cosseno, inserir os fragmentos na instrução e gerar. É um ponto de partida sólido e falha de maneiras previsíveis em grande escala.
Compreender esses modos de falha é um pré-requisito para as técnicas avançadas (reclassificação, compressão e reescrita da consulta) abordadas neste curso.
def naive_rag(query, k=5):
q = embed(query)
chunks = vector_store.search(q, k) # top-k by cosine
context = '\n\n'.join(c.text for c in chunks)
return llm('Context:\n' + context + '\n\nQ: ' + query)Revocação versus precisão da recuperação
A recuperação ingênua dos k primeiros otimiza a similaridade vetorial bruta, confundindo relevância com proximidade semântica superficial. Você enfrenta uma tensão: um k pequeno corre o risco de não encontrar a resposta (baixa revocação); um k grande inunda o contexto com distratores (baixa precisão).
A similaridade entre vetores que orienta a recuperação é um indicador aproximado da relevância real e está na origem de vários problemas posteriores.
# The core dilemma
# small k -> may miss the gold chunk (recall problem)
# large k -> distractors crowd context (precision + cost problem)
# Advanced RAG decouples 'retrieve many' from 'use few'O problema da incompatibilidade de vetorização
Consultas e documentos frequentemente pertencem a registros linguísticos diferentes: uma pergunta curta em comparação com uma passagem longa e declarativa. Os vetores de bi-codificadores podem posicionar uma resposta relevante longe da pergunta porque elas foram formuladas de maneiras diferentes (o problema da incompatibilidade vocabular).
Isso motiva técnicas como a reescrita da consulta e HyDE, que reformulam a consulta para corresponder ao espaço dos documentos antes da recuperação.
# Query: 'how do I revoke a token?'
# Doc: 'Token invalidation is performed via the /sessions endpoint.'
# Lexically and semantically distant -> bi-encoder may miss it
sim = cos(embed('how do I revoke a token?'),
embed('Token invalidation via /sessions')) # may be lowPerdido no meio
Mesmo quando o fragmento correto é recuperado, inserir muitos fragmentos provoca o efeito de perda no meio: o modelo presta menos atenção ao conteúdo colocado no centro de um contexto longo. Um fragmento correto enterrado na posição 3 de 10 pode ser efetivamente ignorado.
Isso motiva a reclassificação (colocar o melhor fragmento onde o modelo presta atenção) e a compressão (reduzir o contexto para que nada fique enterrado).
# Retrieval rank != attention rank
# Place the highest-relevance chunk at the START or END,
# never stranded in the middle of a large concatenation.Sensibilidade a distratores
Os LLMs são sensíveis a contexto irrelevante. Acrescentar fragmentos plausíveis, mas errados, pode desviar a resposta, mesmo quando o fragmento correto também está presente. Mais contexto recuperado não é sempre melhor.
É por isso que a precisão importa: um contexto conciso, reclassificado e comprimido frequentemente supera uma grande quantidade de fragmentos apenas vagamente relacionados.
# Empirically: appending a single highly-similar but WRONG chunk
# can flip a previously-correct answer. RAG quality depends on
# keeping distractors OUT, not just getting the gold chunk IN.Falhas da fragmentação
A fragmentação em tamanho fixo divide ideias no meio de uma frase, separa uma afirmação de suas evidências e remove o contexto estrutural (qual seção, qual documento). Um fragmento que parece coerente isoladamente pode ser inútil ou enganoso sem o contexto ao redor.
Fluxos de processamento avançados usam fragmentação orientada à estrutura, sobreposição, expansão para o documento-pai e metadados para preservar o significado.
def structure_aware_chunks(doc, max_tokens=400, overlap=50):
sections = split_by_headings(doc) # respect document structure
chunks = []
for sec in sections:
for c in sliding_window(sec.text, max_tokens, overlap):
chunks.append(Chunk(c, meta={'section': sec.title}))
return chunksLacunas da recuperação apenas semântica
A recuperação puramente densa não atende às necessidades de correspondência exata: identificadores, códigos de erro, nomes próprios raros e nomes de APIs. É justamente nesses casos que os usuários esperam precisão literal. A recuperação híbrida combina sinais densos (semânticos) e esparsos (BM25/palavras-chave) para abranger os dois tipos.
A fusão recíproca de posições é uma maneira simples e robusta de combinar as duas listas ordenadas sem ajustar um peso.
def rrf(dense_ranks, sparse_ranks, k0=60):
scores = {}
for ranks in (dense_ranks, sparse_ranks):
for rank, doc_id in enumerate(ranks):
scores[doc_id] = scores.get(doc_id, 0) + 1.0 / (k0 + rank)
return sorted(scores, key=scores.get, reverse=True)Contexto desatualizado e não verificável
O RAG ingênuo não tem noção de atualidade nem de procedência. Ele pode recuperar documentos desatualizados e não oferece uma maneira integrada de atribuir afirmações às fontes, o que abala a confiança e dificulta detectar alucinações.
Sistemas avançados anexam metadados (carimbo de data e hora, fonte, versão), filtram com base neles e exigem que o gerador cite os identificadores dos fragmentos para que as respostas possam ser verificadas.
def filtered_retrieve(q, after_date):
cands = vector_store.search(embed(q), k=50)
fresh = [c for c in cands if c.meta['date'] >= after_date]
return fresh # then re-rank; generator must cite c.idSem retorno, sem adaptação
O RAG ingênuo recupera informações sem avaliar os resultados: não consegue saber quando a recuperação falhou, não consegue decidir que nenhuma recuperação é necessária e não consegue repetir o processo. Padrões avançados acrescentam uma verificação de relevância, recuperação condicional e recuperação em várias etapas (agêntica), que reformula a consulta quando os resultados parecem fracos.
O fluxo de processamento se torna um ciclo com autoavaliação, em vez de uma única passagem direta.
def adaptive_rag(q):
chunks = retrieve(q)
if relevance_score(q, chunks) < 0.4:
q2 = rewrite_query(q) # reformulate and retry
chunks = retrieve(q2)
if relevance_score(q, chunks) < 0.4:
return 'I could not find this in the sources.'
return generate(q, chunks)A arquitetura de RAG avançado
Reunindo as falhas, um fluxo de processamento avançado combina: fragmentação orientada à estrutura com metadados, recuperação híbrida com alta revocação, um reclassificador de codificador cruzado para obter precisão, compressão de contexto para ajustar e concentrar o conteúdo, reescrita da consulta / HyDE para corrigir incompatibilidades e um filtro de relevância com citações.
As próximas lições desenvolvem cada camada. A ideia central é: recupere amplamente, depois filtre e refine de forma rigorosa.
def advanced_rag(q):
cands = hybrid_retrieve(rewrite_query(q), k=50) # high recall
top = rerank(q, cands)[:8] # precision
ctx = compress(q, top) # focus + fit
return generate_with_citations(q, ctx) # verifiableMeça antes de otimizar
Diagnostique qual falha você realmente tem antes de acrescentar mecanismos. Meça a revocação da recuperação@k (o fragmento de referência foi recuperado?) separadamente da precisão da resposta (o gerador o utiliza?). Um problema de revocação e um problema de precisão exigem correções diferentes.
Monitore as duas metades; não acrescente um reclassificador quando o seu problema real for a fragmentação ou a incompatibilidade da consulta.
def diagnose(eval_set):
return {
'recall@5': recall_at_k(eval_set, k=5), # retrieval health
'recall@50': recall_at_k(eval_set, k=50), # ceiling with rerank
'answer_acc': answer_accuracy(eval_set), # generation health
}Verificação rápida
Diagnostique um modo de falha do RAG.
Recapitulação
Principais conclusões:
- O RAG ingênuo (fragmentar, vetorizar, selecionar os k primeiros, inserir e gerar) é uma linha de base sólida com falhas previsíveis.
- A similaridade entre bi-codificadores é um indicador aproximado de relevância; a incompatibilidade de registro entre consulta e documento prejudica a revocação.
- Mais contexto não é melhor: a sensibilidade a distratores e a perda no meio degradam as respostas à medida que k aumenta.
- Falhas de fragmentação, lacunas da recuperação apenas semântica, desatualização e falta de retorno limitam o RAG ingênuo.
- O RAG avançado recupera amplamente e depois filtra: recuperação híbrida, reclassificação, compressão, reescrita da consulta e filtragem por relevância. Meça a revocação e a precisão da resposta separadamente antes de otimizar.
Aprenda AI Prompt Engineering com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 53
- Aulas
- 199
Perguntas Frequentes
A aula “Além do RAG ingênuo” é grátis?
Sim — o texto completo de “Além do RAG ingênuo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.
O que vou aprender em “Além do RAG ingênuo”?
Conheça as limitações da recuperação básica. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Prompt Engineering?
Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Além do RAG ingênuo”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Prompt Engineering?
Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Além do RAG ingênuo
- Reordenando trechos recuperados
- Compressão de contexto
- Reformulação de consultas e HyDE