Skip to content

Geração Aumentada por Recuperação (RAG)

RAG (Retrieval-Augmented Generation) é uma técnica que combina modelos de linguagem pré-treinados com sistemas de recuperação de informação. Ela faz com que o LLM “busque” dados externos relevantes (uma base de conhecimento) antes de gerar respostas[1][2]. Em vez de confiar apenas no conhecimento embutido no modelo, o RAG recupera documentos ou trechos de texto relevantes (via embeddings e pesquisa semântica) e usa esses dados como contexto para a geração da resposta[3][2]. Isso otimiza a precisão e atualidade dos resultados, principalmente em domínios específicos, sem precisar retreinar o modelo completo[1][4].

Arquitetura e Pipeline

Uma aplicação típica de RAG envolve duas fases principais: indexação e recuperação/geração[5][6].

  • Indexação (pré-processamento): carrega-se a base de dados (por exemplo, documentos, PDFs ou páginas web) usando loaders adequados[5]. Em seguida, o texto é fragmentado em pedaços menores (usando um TextSplitter) para facilitar a busca[5]. Cada pedaço de texto é então convertido em vetor numérico por meio de um modelo de embedding (como o OpenAIEmbeddings) e armazenado num banco vetorial (VectorStore)[5]. Essa etapa estrutura o conhecimento, permitindo pesquisas semânticas eficientes.
  • Recuperação e geração (runtime): dada uma consulta do usuário, o sistema converte a pergunta em embedding e usa um retriever para encontrar os fragmentos mais relevantes no índice pré-computado[6][3]. Por fim, um modelo de linguagem (por exemplo, GPT ou outro LLM) recebe a pergunta junto com os trechos recuperados e gera uma resposta contextualizada[6][7]. Ou seja, o modelo lê o material recuperado e produz uma resposta factual e precisa em vez de depender apenas do seu conhecimento interno[6][7].

Esse fluxo — documentos carregados ➔ fragmentados ➔ indexados em vetor store ➔ consulta do usuário ➔ busca semântica ➔ geração com contexto — é a essência da RAG[5][6]. Bibliotecas como o LangChain facilitam essa arquitetura, oferecendo document loaders, text splitters, modelos de embeddings, vetores e cadeias (chains) de RAG prontas para uso.

Casos de Uso

RAG é especialmente útil em aplicações que exigem respostas precisas e baseadas em dados específicos. Entre os casos de uso mais comuns estão:

  • Sistemas de Perguntas e Respostas (Q&A): RAG permite usuários fazerem perguntas e receber respostas detalhadas e relevantes baseadas em documentos de referência. Em comparação com sistemas tradicionais, ele oferece maior precisão e profundidade de conhecimento[8].
  • Chatbots e assistentes virtuais: Ao criar chatbots de atendimento ou suporte, RAG ajuda a fornecer respostas variadas e informativas mesmo em conversas complexas. Por exemplo, um chatbot no setor de seguros pode acessar políticas e manuais para responder dúvidas sobre benefícios e sinistros[9].
  • Aplicações educacionais: Em plataformas de ensino, RAG pode não só responder perguntas de alunos como também explicar as etapas de resolução ou gerar material de estudo com base em livros-texto e artigos relevantes[10]. Isso enriquece a experiência de aprendizado em todos os níveis educacionais[10].
  • Geração de conteúdo e relatórios: Para marketing, jornalismo ou análise de dados, RAG pode recuperar informações atuais e gerar relatórios resumidos ou conteúdos criativos (artigos, postagens em rede social, roteiros) de forma automatizada[11]. Isso acelera a pesquisa e aumenta a produtividade de quem cria conteúdo.
  • Conhecimento corporativo: Quase qualquer empresa pode transformar manuais, políticas e logs internos em bases de conhecimento que alimentam assistentes internos. Esses assistentes podem ajudar em suporte ao cliente, treinamento de funcionários ou aumento de produtividade de desenvolvedores[12]. Em suma, RAG viabiliza “conversas” com repositórios de dados em linguagem natural, abrindo amplos usos em diversos setores[13][8].

Benefícios

A RAG traz diversas vantagens sobre o uso de LLMs isoladamente:

  • Atualização constante: Um LLM pré-treinado tem base de conhecimento fixa (até uma certa data de corte). Com RAG, conectamos o modelo a dados atualizados em tempo real (ex.: notícias, repositórios internos), mantendo as respostas relevantes[14][15]. Isso evita respostas obsoletas ou genéricas.
  • Maior precisão e menor risco de “alucinação”: Ao fundamentar as respostas em fontes externas confiáveis, RAG reduz a tendência do modelo de inventar informações. O modelo “ancora” suas respostas em fatos existentes, aumentando a confiabilidade[16][17]. Além disso, é possível incluir citações das fontes usadas, o que permite ao usuário verificar as informações[17][18].
  • Custo-efetividade: Introduzir novos dados via RAG é muito mais econômico do que retreinar ou ajustar finamente o modelo com grandes quantidades de texto. Em vez de pagar pelo pesado fine-tuning, a empresa simplesmente indexa os dados relevantes e deixa que o LLM os consulte[19][20]. Isso facilita escalar aplicações de IA sem altos custos de processamento.
  • Controle do desenvolvedor: RAG dá ao desenvolvedor controle sobre as fontes de informação. É possível adicionar, atualizar ou restringir os documentos usados sem mudar o modelo em si[21][18]. Dados sensíveis podem ficar protegidos “on-premise” enquanto apenas trechos autorizados são disponibilizados ao LLM[21][22]. Isso melhora a segurança e conformidade do sistema.
  • Experiência do usuário: Por apresentar respostas com fontes e mais contextuais, RAG aumenta a confiança dos usuários no chatbot ou sistema de IA[23][17]. Saber que as respostas vêm de documentos reais (que podem ser checados) evita o ceticismo típico de saídas dos LLMs não referenciadas.

Em resumo, RAG combina o melhor de dois mundos: a fluência dos grandes modelos de linguagem com a precisão de bases de conhecimento específicas[1][4].

Codigo de exemplo

Para rodar o codigo voce precisará de um ambiente que atenda a estes requisitos:

Python 3.7 ou superior.

Variáveis de Ambiente: Um arquivo .env na raiz do projeto com as suas chaves de API para o Google Gemini. O código utiliza a função load_dotenv para carregar essas chaves.

Bibliotecas Python

Bash

pip install langchain langchain-google-genai langchain_chroma bs4 langgraph

O codigo funciona da seguinte maneire, ele puxa os dados de html de um blog, divide eles em chunks, usa o embedding para transformar esses textos em vetores numericos que mais bem compreendidos pelo computador, eles são salvos de maneire indexada com base em palavras chave Após o usuario mandar uma pergunta, o retriever olha a pergunta e procura contexto pertinente com base em palavras chave, retornando para uma llm o contexto e o prompt para assim o usuario receber uma resposta mais precisa do sistema.

from dotenv import load_dotenv
from langchain_google_genai import GoogleGenerativeAIEmbeddings
from langchain.chat_models import init_chat_model
from langchain_chroma import Chroma
import bs4
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain import hub
from langchain_core.documents import Document
from typing_extensions import List, TypedDict
from langgraph.graph import START, StateGraph
from langchain_core.prompts import PromptTemplate


load_dotenv()

llm = init_chat_model("gemini-2.5-flash", model_provider="google_genai")
embeddings = GoogleGenerativeAIEmbeddings(model="models/gemini-embedding-001")

vector_store = Chroma(
    collection_name="example_collection",
    embedding_function=embeddings,
    persist_directory="./chroma_langchain_db",  # Banco de dados para os vetores de informação
)

bs4_strainer = bs4.SoupStrainer(class_=("post-title", "post-header", "post-content")) # Retira apenas o necessario do site
loader = WebBaseLoader(
    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
    bs_kwargs={"parse_only": bs4_strainer},
)
docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,  # chunk size (characters)
    chunk_overlap=200,  # chunk overlap (characters)
    add_start_index=True,  # track index in original document
)
all_splits = text_splitter.split_documents(docs)

document_ids = vector_store.add_documents(documents=all_splits)

prompt = hub.pull("rlm/rag-prompt")

example_messages = prompt.invoke(
    {"context": "(context goes here)", "question": "(question goes here)"}
).to_messages()

class State(TypedDict):
    question: str
    context: List[Document]
    answer: str

def retrieve(state: State):
    retrieved_docs = vector_store.similarity_search(state["question"])
    return {"context": retrieved_docs}


def generate(state: State):
    docs_content = "\n\n".join(doc.page_content for doc in state["context"])
    messages = prompt.invoke({"question": state["question"], "context": docs_content})
    response = llm.invoke(messages)
    return {"answer": response.content}

graph_builder = StateGraph(State).add_sequence([retrieve, generate])
graph_builder.add_edge(START, "retrieve")
graph = graph_builder.compile()

response = graph.invoke({"question": "What is Task Decomposition?"})
print(response["answer"])

Considerações Finais

A geração aumentada por recuperação (RAG) é uma técnica poderosa para criar aplicações de IA mais precisas e confiáveis. Ao integrar busca de informações e modelos de linguagem, ela permite que chatbots e sistemas de QA funcionem com dados atuais e específicos, sem exigirem modelos caros e estáticos. O uso de frameworks como LangChain simplifica essa implementação, fornecendo abstrações de loaders, vetores e chains prontas. Em resumo, o RAG amplia significativamente as capacidades dos LLMs, tornando-os capazes de responder com base em conhecimentos reais e atualizados[1][4].

Fontes: As informações acima foram compiladas de documentos oficiais e artigos especializados sobre RAG, incluindo materiais da LangChain[5][6], AWS[1][19], NVIDIA[4][17], IBM[20][29] e publicações técnicas relevantes[30][11]. Cada afirmação está embasada nas referências indicadas.

[1] [3] [14] [19] [21] [23] What is RAG? - Retrieval-Augmented Generation AI Explained - AWS

https://aws.amazon.com/what-is/retrieval-augmented-generation/

[2] [8] [9] [10] [11] [30] What Is Retrieval Augmented Generation (RAG)? An Overview

https://www.couchbase.com/blog/pt/an-overview-of-retrieval-augmented-generation/

[4] [12] [13] [17] What Is Retrieval-Augmented Generation aka RAG | NVIDIA Blogs

https://blogs.nvidia.com/blog/what-is-retrieval-augmented-generation/

[5] [6] Build a Retrieval Augmented Generation (RAG) App: Part 1 | ️ LangChain

https://python.langchain.com/docs/tutorials/rag/

[7] [24] [25] [26] [27] [28] How to Build a Retrieval-Augmented Generation Chatbot | Anaconda

https://www.anaconda.com/blog/how-to-build-a-retrieval-augmented-generation-chatbot

[15] [16] [18] [20] [29] What is RAG (Retrieval Augmented Generation)? | IBM

https://www.ibm.com/think/topics/retrieval-augmented-generation

[22] O que é geração aumentada de recuperação (RAG)?

https://www.redhat.com/pt-br/topics/ai/what-is-retrieval-augmented-generation