Key Takeaways
- RAG = carregar documentos + deixar o modelo responder perguntas sobre eles citando fontes.
- Open WebUI tem o RAG integrado mais fácil. Carregue um PDF, faça perguntas. Configuração em 5 minutos.
- LlamaIndex é o framework mais flexível para construir pipelines de RAG.
- LangChain é o framework profissional mais utilizado, com um ecossistema massivo.
- Chroma e Qdrant são os principais bancos de dados vetoriais para armazenar chunks de documentos.
- Em abril de 2026, o RAG local está maduro e pronto para produção.
O que é RAG (Retrieval-Augmented Generation)?
RAG é uma técnica que permite ao seu LLM responder perguntas sobre os seus próprios documentos sem precisar fazer fine-tuning no modelo.
O processo: (1) Carregue seus documentos (PDFs, arquivos de texto), (2) divida-os em chunks, (3) converta os chunks em embeddings (vetores numéricos), (4) armazene os embeddings em um banco de dados vetorial, (5) quando fizer uma pergunta, recupere os chunks relevantes do banco de dados, (6) passe os chunks + pergunta ao LLM, (7) o LLM responde com base nos chunks.
RAG é preferível ao fine-tuning quando seus documentos mudam com frequência (o fine-tuning é um treinamento único) e você precisa de atribuição de fontes (RAG mostra quais documentos foram usados).
As 8 melhores ferramentas RAG locais em 2026
| Ferramenta | Tipo | Ideal para | Banco de dados vetorial | Curva de aprendizado |
|---|---|---|---|---|
| Open WebUI | Aplicativo web (Docker) | Iniciantes, configuração mais simples | Integrado | Nenhuma |
| LlamaIndex | Framework Python | Pipelines flexíveis | Qualquer (Chroma, Qdrant, Pinecone) | Média |
| LangChain | Framework Python | Sistemas de produção | Qualquer | Média |
| Chroma | Banco de dados vetorial | RAG simples | Chroma (incorporado) | Baixa |
| Qdrant | Banco de dados vetorial | RAG escalável | Qdrant (distribuído) | Média |
| Weaviate | Banco de dados vetorial | Consultas GraphQL | Weaviate | Média |
| Milvus | Banco de dados vetorial | Grande escala | Milvus | Alta |
| Text-Generation-WebUI RAG | Extensão | Integrado com o modelo | Integrado | Baixa |
Como usar o Open WebUI RAG (a opção mais fácil)?
O Open WebUI tem RAG integrado. Sem configuração adicional além do Docker. Basta carregar documentos e fazer perguntas.
# 1. Executar Open WebUI com Docker
docker run -d -p 3000:8080 \
-e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
ghcr.io/open-webui/open-webui:latest
# 2. Abra http://localhost:3000
# 3. Clique em "+" ao lado do campo de mensagem → "Carregar arquivos"
# 4. Selecione PDFs ou arquivos de texto
# 5. Faça perguntas -- Open WebUI recupera os chunks relevantes
# 6. O modelo responde com base nos documentos, com citaçõesComo construir RAG com LlamaIndex?
LlamaIndex é um framework que gerencia carregamento de documentos, chunking, embedding e recuperação. Flexível, compatível com qualquer banco de dados vetorial.
# 1. Instalar
pip install llama-index
pip install llama-index-embeddings-ollama # usar embeddings do Ollama localmente
pip install llama-index-vector-stores-chroma # usar Chroma para armazenamento
# 2. Pipeline RAG simples
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.embeddings.ollama import OllamaEmbedding
# Carregar documentos
documents = SimpleDirectoryReader("./documents").load_data()
# Criar índice com embeddings locais
embedding_model = OllamaEmbedding(model_name="nomic-embed-text")
index = VectorStoreIndex.from_documents(
documents,
embed_model=embedding_model
)
# Consulta
query_engine = index.as_query_engine()
response = query_engine.query("What does the document say about X?")
print(response)Como construir RAG com LangChain?
LangChain é o framework mais utilizado para sistemas RAG em produção. Compatível com todos os bancos de dados vetoriais e provedores de LLM.
# pip install langchain langchain-community langchain-chroma
from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.chat_models import ChatOllama
from langchain.chains import RetrievalQA
# Carregar documentos
loader = DirectoryLoader("./documents")
docs = loader.load()
# Dividir em chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
chunks = splitter.split_documents(docs)
# Criar embeddings e vector store
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(chunks, embeddings)
# Criar cadeia QA
llm = ChatOllama(model="llama3.2:8b")
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever()
)
# Responder perguntas
result = qa.run("What does the document say about X?")
print(result)Quais bancos de dados vetoriais são melhores para RAG local?
Chroma (o mais simples): Banco de dados vetorial em processo. Sem configuração de servidor. Ideal para projetos RAG pequenos (< 1M documentos).
Qdrant (escalável): Auto-hospedado ou na nuvem. Melhor para RAG em grande escala. Mais funcionalidades que Chroma.
Weaviate: Baseado em GraphQL. Bom para consultas complexas sobre embeddings.
Milvus: Nível empresarial. Para RAG massivo (100M+ documentos).
Para a maioria dos deployments locais, Chroma é suficiente e o mais simples.
Você deve usar RAG ou fine-tuning?
Use este critério:
- Use RAG se: seus documentos mudam com frequência, você precisa de atribuição de fontes, quer zero treinamento do modelo, ou tem menos de 100K documentos.
- Use fine-tuning se: sua base de conhecimento é fixa, quer que o modelo realmente "entenda" o domínio, ou precisa de velocidade de inferência (modelos com fine-tuning são mais rápidos).
- Combine os dois: Faça fine-tuning de um modelo no seu domínio e adicione RAG por cima para Q&A de altíssima qualidade.
Erros comuns com RAG local
- Usar o tamanho de chunk errado. Muito pequeno (100 tokens) = muitos pedaços pequenos. Muito grande (2000 tokens) = pouco específico. O ideal é 500-1000 tokens.
- Esquecer de usar embeddings. Você não pode fazer RAG sem converter os chunks em embeddings. Use `nomic-embed-text` (melhor para inglês) ou `bge-m3` (multilíngue).
- Não avaliar a qualidade da recuperação. O fato de o RAG funcionar não significa que ele recupera os documentos certos. Teste com perguntas conhecidas e verifique se os chunks recuperados são relevantes.
- Tratar RAG como substituto do fine-tuning. RAG é recuperação + aprendizado em contexto. Fine-tuning é adaptação real do modelo. Ferramentas diferentes para usos diferentes.
Perguntas frequentes sobre RAG local
Quantos documentos o RAG local consegue gerenciar?
Depende do banco de dados vetorial. Chroma gerencia 100K-1M documentos facilmente em hardware de consumo. Acima de 1M, use Qdrant ou Milvus.
O RAG funciona com imagens?
Somente se você extrair texto primeiro (OCR). Para compreensão real de imagens, use modelos multimodais como Llama 3.2 Vision com RAG.
O RAG é mais lento que o fine-tuning?
RAG requer recuperação (milissegundos) + passagem de contexto (tokens adicionados ao prompt). Tipicamente mais lento que a inferência com fine-tuning, mas muito mais rápido de configurar.
Posso usar embeddings na nuvem com LLMs locais?
Sim. Use embeddings na nuvem (OpenAI, Cohere) para recuperação e LLMs locais para respostas. A abordagem híbrida é comum.
Fontes
- Documentação do LlamaIndex -- docs.llamaindex.ai
- Documentação do LangChain -- python.langchain.com
- Documentação do Chroma -- docs.trychroma.com
- Documentação do Qdrant -- qdrant.tech/documentation
- Artigo RAG -- arxiv.org/abs/2005.11401