Como RAG e fine-tuning de modelos podem melhorar as respostas dos seus agentes e diminuir custos na sua empresa

Tema: Modelos de Linguagem (LLMs) e Machine Learning

A conta dos agentes de inteligência artificial finalmente chegou às mesas de orçamento. Depois de uma fase de experimentação acelerada, empresas que colocaram assistentes virtuais em atendimento, jurídico, suporte técnico e vendas descobriram um padrão incômodo: o modelo generalista responde bem ao protótipo e mal à produção — erra detalhes do produto, ignora a política interna, escreve no tom errado e cobra por token a cada tentativa. A resposta técnica que ganhou tração em 2025 e 2026 combina duas estratégias distintas, frequentemente confundidas: geração aumentada por recuperação (RAG) e ajuste fino (fine-tuning), de preferência sobre modelos abertos rodando em infraestrutura própria.

A lógica é separar o que o modelo precisa saber do que ele precisa fazer. O RAG injeta conhecimento atualizado no momento da consulta, sem retreinar nada [2]. O fine-tuning altera os pesos do modelo e molda comportamento, como tom e terminologia do domínio [2][19]. E modelos abertos de porte médio, como o Qwen3.8-27B, tornaram viável executar essa combinação dentro do data center do cliente [8][9].

RAG: transformar os documentos da empresa em contexto recuperável

Um sistema de RAG nasce de um pipeline simples na descrição e trabalhoso na execução. Os documentos internos — manuais, contratos, tickets, políticas de preço — são quebrados em trechos (chunks), convertidos em vetores por um modelo de embeddings e gravados em um índice vetorial. Quando o usuário faz uma pergunta, a mesma técnica converte a consulta em vetor, busca os trechos mais próximos e insere apenas esse material no prompt enviado ao modelo, que redige a resposta a partir dali [2]. A arquitetura foi formalizada por Patrick Lewis e coautores em 2020, ao combinar memória paramétrica (os pesos do modelo) e não paramétrica (um índice de documentos externos), obtendo estado da arte em três tarefas de perguntas e respostas de domínio aberto [1].

O que isso resolve é direto: o agente passa a responder com base na documentação da empresa, e o conhecimento novo entra assim que é indexado — sem retreinamento, sem nova rodada de GPU [2]. Como a resposta é ancorada em trechos identificáveis, é possível citar a fonte consultada, o que melhora a experiência do usuário e torna a resposta conferível [12]. A IBM descreve o mesmo movimento como conectar o modelo ao banco de dados proprietário da organização em vez de retreiná-lo [13].

Os limites, porém, são de recuperação, não de geração. A Anthropic mostrou que a forma de preparar o índice altera o resultado de maneira mensurável: sua técnica de contextual retrieval, que acrescenta contexto a cada chunk antes da indexação, reduziu em 49% a taxa de falha na recuperação dos 20 principais trechos quando aplicada a embeddings e à busca BM25, e em 67% quando combinada com reranking [3]. Usados sozinhos, os embeddings contextuais cortaram essa taxa em 35% [3][20]. Há ainda o problema de posição: modelos costumam usar melhor informações no início e no fim de contextos longos e pioram quando o dado relevante está no meio [4]. E recuperar demais custa caro: um fornecedor de RAG estima de 3 mil a 8 mil tokens por tarefa quando se enviam apenas trechos ranqueados, contra 50 mil a 200 mil tokens quando se enviam documentos inteiros [18].

Fine-tuning: quando o problema é comportamento, não informação

Fine-tuning é outra operação. Em vez de mudar o que entra no prompt, altera os pesos do modelo a partir de exemplos do domínio — pares de pergunta e resposta, laudos padronizados, pareceres, scripts de atendimento. O custo histórico dessa operação caiu com técnicas de ajuste eficiente de parâmetros. O LoRA congela os pesos originais e injeta matrizes de decomposição de posto baixo treináveis; comparado ao ajuste completo do GPT-3 de 175 bilhões de parâmetros com Adam, reduz o número de parâmetros treináveis em 10 mil vezes e a memória de GPU em cerca de três vezes [5]. O QLoRA foi além ao quantizar o modelo base, permitindo ajustar um modelo de 65 bilhões de parâmetros em uma única GPU de 48 GB preservando o desempenho do ajuste completo em 16 bits [6].

O que o ajuste resolve é comportamento: tom de voz e terminologia do domínio [19] e, de modo geral, formato de saída mais previsível em tarefas repetitivas. A Databricks resume a assimetria: o RAG conecta o modelo a dados externos no momento da consulta, enquanto o fine-tuning altera de forma permanente os pesos internos do modelo [2].

O limite é decisivo: fine-tuning não é bom para fatos que mudam. Um preço reajustado na segunda-feira não estará nos pesos ajustados na sexta anterior; o modelo ajustado fica preso ao retrato dos dados no momento do treino, e cada atualização exige nova coleta de dados e novo ciclo de treinamento [2]. Some-se o custo computacional de cada rodada, que exige GPUs potentes [13], e o trabalho contínuo de curadoria de dados e reavaliação do modelo, que muitos projetos subestimam.

Modelos abertos em servidor próprio: a economia por consulta

A terceira peça é de infraestrutura. Modelos abertos de porte médio passaram a entregar qualidade suficiente para tarefas delimitadas. O Qwen3.8-27B é um modelo denso de 27 bilhões de parâmetros, com licença Apache 2.0, capacidade de visão, janela de contexto nativa de 262.144 tokens — extensível até 1 milhão — e benchmarks publicados que incluem 61,7 no SWE-bench Pro e 73,0 no Terminal-Bench 2.1 [8][10]. Em formatos quantizados, roda localmente com cerca de 17 GB de RAM ou VRAM [9]. A geração Qwen3, que antecedeu essa linha, foi documentada em relatório técnico de 2025, com modelos densos e de mistura de especialistas de 0,6 bilhão a 235 bilhões de parâmetros [7].

Esses modelos não servem só para responder: podem ser ajustados no próprio servidor. O guia de fine-tuning do Qwen3.8 publicado pela Unsloth indica que o QLoRA do Qwen3.8-27B funciona com 24 GB de VRAM, que o LoRA exige mais de 36 GB e que o ajuste completo usa cerca de quatro vezes mais memória [21]. Modelos abertos menores reduzem ainda mais a exigência: a mesma documentação afirma que é possível ajustar modelos localmente com apenas 3 GB de VRAM e traz tutoriais para outras famílias, como o Llama 3 [22]. Na prática, a mesma máquina que serve o modelo pode receber um adaptador LoRA treinado com dados da empresa, consultar um índice de documentos a cada pergunta ou fazer as duas coisas: o adaptador cuida do comportamento e o índice, do conhecimento atualizado [2][19].

Rodar esse modelo em servidor próprio muda a economia e o controle. Do lado do desempenho de serving, o vLLM com PagedAttention reportou até 24 vezes mais throughput que o HuggingFace Transformers sem alterar o modelo [14]; o artigo que introduziu a técnica descreve ganhos de 2 a 4 vezes sobre sistemas como FasterTransformer e Orca, com latência equivalente [15]. Do lado da governança, o processamento ocorre em infraestrutura controlada pela própria organização — ponto sensível sob a LGPD, que exige saber onde os dados são processados [17].

E por que um modelo menor, ajustado e conectado a um índice, pode responder tão bem quanto um modelo grande genérico? Porque a comparação relevante não é de conhecimento geral, e sim de tarefa. Um estudo de 2024 mostrou que LLMs pequenos ajustados superam de forma consistente e significativa modelos maiores apenas instruídos por prompt em classificação de texto [11]. O próprio trabalho do QLoRA relata resultados de estado da arte com modelos menores que os anteriores, a partir de conjuntos de dados pequenos e de alta qualidade [6]. Em domínio estreito, especialização vence escala bruta.

Quando usar RAG, quando usar fine-tuning e quando combinar

O critério prático cabe em uma pergunta: o problema é informação ou comportamento? Se a resposta certa depende de um documento que muda — tabela de preços, política de troca, jurisprudência recente, versão de firmware —, o caminho é RAG [2][13]. Se a resposta certa já é conhecida, mas chega com tom, terminologia ou formato inadequados, o caminho é fine-tuning [19].

Em atendimento, a combinação é o padrão mais comum: RAG sobre a base de políticas e produtos garante exatidão, enquanto o ajuste fixa o tom da marca e o formato de resposta para o agente. No jurídico, RAG sobre contratos e acórdãos permite citar a fonte de cada resposta [12], o que facilita a conferência; o ajuste entra para padronizar pareceres e resumos. Em suporte técnico, RAG nos manuais resolve a recuperação e o ajuste ensina o formato de diagnóstico em etapas. Em vendas, o ajuste molda a abordagem e o RAG puxa catálogo, disponibilidade e condição comercial vigente.

Volume de consultas e sensibilidade dos dados fecham a decisão. O custo de APIs cresce com a escala, enquanto o hardware local é um custo fixo que não se justifica com volume baixo e irregular [17]; e o mesmo guia recomenda IA local para cargas de trabalho sensíveis e recorrentes, e APIs na nuvem para experimentos e demandas pontuais [17]. A Databricks observa que a maioria dos sistemas em produção combina os dois: um modelo ajustado cuida do tom e da terminologia do domínio, enquanto o fluxo de RAG fornece acesso ao conhecimento [19].

Onde o custo cai, de fato

A redução de custo não vem de um único fator, mas de quatro efeitos somados. Primeiro, menos tokens por consulta: enviar ao modelo apenas os trechos ranqueados, em vez de documentos inteiros, diminui a entrada [18]. Segundo, cache de prompt: a Anthropic relata redução de custo de até 90% e de latência de até 85% em prompts longos com conteúdo reaproveitado [16]. Terceiro, modelo menor: com volume alto, um modelo de 27 bilhões de parâmetros em infraestrutura própria pode ter custo marginal por consulta menor que o de uma API de fronteira, e o serving eficiente amplia essa vantagem [14][15]. Quarto, menos retrabalho: resposta ancorada em fonte e formatada de forma consistente reduz revisão humana e reincidência de erro — o gasto que raramente aparece na planilha de TI, mas aparece na operação.

Conclusão

A combinação que se consolidou não é moda: é engenharia. RAG resolve conhecimento mutável e rastreável; fine-tuning resolve comportamento previsível; modelos abertos de porte médio em servidor próprio resolvem custo, latência e soberania de dados. Empresas que tratam as três decisões separadamente — e escolhem o modelo depois de definir o caso de uso, não antes — tendem a sair do piloto com um agente que erra menos e custa menos por resposta. O próximo passo previsível é a consolidação: menos fornecedores, mais avaliação contínua e um catálogo interno de casos de uso com métricas de acerto e custo por consulta.

A Quântica.ia implanta RAG e fine-tuning em infraestrutura própria do cliente, do índice de documentos ao ajuste eficiente de modelos abertos — saiba mais em https://quanticaia.com.br/solucoes/fine-tuning-llms/

Referências

  1. [1] Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (Lewis et al., 2020) - https://arxiv.org/abs/2005.11401
  2. [2] RAG vs Fine Tuning: Enterprise Decisions for AI Models (Databricks) - https://www.databricks.com/blog/rag-vs-fine-tuning
  3. [3] Contextual Retrieval (Anthropic Research) - https://www.anthropic.com/research/contextual-retrieval
  4. [4] Lost in the Middle: How Language Models Use Long Contexts (Liu et al.) - https://arxiv.org/abs/2307.03172
  5. [5] LoRA: Low-Rank Adaptation of Large Language Models (Hu et al., 2021) - https://arxiv.org/abs/2106.09685
  6. [6] QLoRA: Efficient Finetuning of Quantized LLMs (Dettmers et al., 2023) - https://arxiv.org/abs/2305.14314
  7. [7] Qwen3 Technical Report - https://arxiv.org/abs/2505.09388
  8. [8] Qwen/Qwen3.8-27B (Hugging Face) - https://huggingface.co/Qwen/Qwen3.8-27B
  9. [9] Qwen3.8 — How to Run Locally (Unsloth Docs) - https://unsloth.ai/docs/models/qwen3.8
  10. [10] Qwen 3.8 27B: Benchmarks, VRAM, License, and How to Run It (Morph) - https://www.morphllm.com/qwen-3-8

  11. [11] Fine-Tuned 'Small' LLMs (Still) Significantly Outperform Zero-Shot Generative AI Models in Text Classification (Bucher & Martini, 2024) - https://arxiv.org/abs/2406.08660

  12. [12] RAG 101: Retrieval-Augmented Generation Questions Answered (NVIDIA Developer) - https://developer.nvidia.com/blog/rag-101-retrieval-augmented-generation-questions-answered/
  13. [13] Qual a diferença entre RAG e Fine Tuning? (IBM Brasil) - https://www.ibm.com/br-pt/think/topics/rag-vs-fine-tuning
  14. [14] Easy, Fast, and Cheap LLM Serving with PagedAttention (vLLM Blog) - https://vllm.ai/blog/2023-06-20-vllm
  15. [15] Efficient Memory Management for Large Language Model Serving with PagedAttention (Kwon et al., 2023) - https://arxiv.org/abs/2309.06180
  16. [16] Prompt caching with Claude (Anthropic) - https://claude.com/blog/prompt-caching
  17. [17] IA Local para Empresas: Guia Prático (Atacama Digital) - https://atacama.digital/blog/ia-local-para-empresas
  18. [18] RAG Token Costs: Retrieval vs Combing Sources (Onyx) - https://onyx.app/insights/rag-token-costs
  19. [19] End-to-End RAG Workflow: How Retrieval Augmented Generation Works (Databricks) - https://www.databricks.com/blog/rag-workflow
  20. [20] Enhancing RAG with Contextual Retrieval (Claude Cookbook, Anthropic) - https://platform.claude.com/cookbook/capabilities-contextual-embeddings-guide
  21. [21] Qwen3.8 Fine-tuning Guide (Unsloth Documentation) - https://unsloth.ai/docs/models/qwen3.8/train
  22. [22] Fine-tuning LLMs Guide (Unsloth Documentation) - https://unsloth.ai/docs/get-started/fine-tuning-llms-guide
Fale com a Eliza
E

Eliza

Agente assistente