RAG local com Ollama sem programar (Open WebUI, AnythingLLM)

#Por que usar um RAG local com Ollama

Um RAG (Retrieval-Augmented Generation) resolve uma limitação simples dos LLM: eles conhecem apenas seus dados de treinamento. O RAG conecta os modelos aos seus documentos: PDFs de procedimentos internos, anotações em Markdown, exportações de e-mails, contratos, manuais — tudo o que não seja público nem recente. O modelo lê os trechos relevantes antes de responder e cita as fontes, se o recurso estiver disponível.

A versão na nuvem (ChatGPT, Claude, Gemini) exige que você envie seus documentos para servidores de terceiros. Para um escritório de advocacia, um médico, um contador ou até uma pessoa que não quer ver suas notas pessoais enviadas aos Estados Unidos, isso é inaceitável. Um RAG local com Ollama resolve esse problema: tudo permanece na sua máquina, e você mantém o controle tanto dos custos (zero) quanto da confidencialidade.

Confidencialidade total

Seus documentos nunca saem da máquina. Nenhum token é enviado para um provedor.

Custo marginal nulo

Sem assinatura, sem limite de API. Você paga pela eletricidade, é isso.

Offline

Após o modelo ser baixado, o RAG funciona sem conexão com a internet.

Personalizável

Você escolhe o modelo de resposta, o modelo de embeddings e as fontes.

#Ollama faz RAG nativamente?

Resposta clara: não. Ollama é um motor de inferência — ele baixa e executa LLMs, expõe uma API compatível com OpenAI em http://localhost:11434, mas não sabe indexar seus documentos sozinho. Ele não possui banco de dados vetorial, nem ferramenta para dividir PDFs em trechos, nem interface para arrastar e soltar arquivos.

Por outro lado, ele consegue servir um modelo de geração e um modelo de embeddings em paralelo — é tudo o que é necessário para que uma ferramenta de terceiros (Open WebUI, AnythingLLM, LangChain…) construa um RAG sobre ele. Portanto, quando se fala em RAG local com Ollama, trata-se sempre de uma combinação Ollama + interface RAG.

#Pré-requisitos

Ollama instalado

No Windows, macOS ou Linux. Por padrão, fica escutando em http://localhost:11434.

Um modelo de resposta

Granite 4.2 8B ou Qwen 3.5 9B em Q4_K_M. Prever cerca de 5 a 7 GB de VRAM ou RAM.

Um modelo de embeddings

nomic-embed-text ou mxbai-embed-large. ~300 MB. Essencial para vetorizar documentos.

Docker (opção Open WebUI)

Docker Desktop no Windows/macOS, ou docker.io no Linux. Esse é o modo de instalação recomendado.

Espaço em disco

No mínimo 10 GB para o modelo LLM + embeddings + o índice vetorial dos seus documentos.

# Le LLM qui va répondre
ollama pull qwen3.5:9b

# Le modèle d'embeddings (obligatoire pour le RAG)
ollama pull nomic-embed-text

# Vérifier que les deux sont bien là
ollama list

#1. Open WebUI : base de conhecimento integrada

O Open WebUI (antigo Ollama WebUI) é a interface semelhante ao ChatGPT mais popular para o Ollama. Sua funcionalidade Knowledge (base de conhecimento) permite enviar documentos e consultá-los via RAG, sem precisar configurar nada no código.

1. 01
   Iniciar o Open WebUI com Docker

   Em um terminal: docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main. No Linux nativo, substituir host.docker.internal por localhost se você executar Ollama fora do Docker.
2. 02
   Abrir a interface

   Acessar http://localhost:3000. Criar uma conta de administrador (a primeira conta é de administrador por padrão). O Open WebUI detecta automaticamente o Ollama em localhost:11434.
3. 03
   Criar uma base de conhecimento

   Acessar Workspace → Knowledge → + Create a Knowledge Base. Dar um nome (ex.: 'Contratos de clientes'). Esse é seu contêiner vetorial.
4. 04
   Importar seus documentos

   Clicar no + no canto superior direito da base e depois enviar seus arquivos PDF, .docx, .md, .txt. O Open WebUI os divide em partes e calcula os embeddings em segundo plano.
5. 05
   Configurar o modelo de embeddings

   Settings (admin) → Documents → Embedding Model Engine = Ollama, Embedding Model = nomic-embed-text. Salvar. Sem isso, o Open WebUI usa um modelo padrão menos adequado ao francês.
6. 06
   Consultar a base

   Em um novo chat, digitar # seguido do nome da base de conhecimento para anexá-la. Fazer sua pergunta — a resposta é gerada com base nos trechos relevantes, com números de citação clicáveis.

#2. AnythingLLM: workspaces e citações

O AnythingLLM é a alternativa mais completa ao Open WebUI no que diz respeito ao RAG. Enquanto o Open WebUI é generalista, o AnythingLLM é projetado em torno da noção de workspace: cada projeto tem sua própria base de documentos, seu próprio modelo e seu próprio histórico. Ideal quando você quer separar 'Contratos de clientes' de 'Anotações pessoais' de 'Documentação técnica'.

1. 01
   Instalar o AnythingLLM

   Baixar o instalador Desktop em useanything.com para Windows, macOS ou Linux. É um aplicativo Electron — não é necessário Docker para a versão desktop.
2. 02
   Escolher Ollama como provedor de LLM

   Na primeira execução, o assistente pergunta qual LLM usar. Selecionar Ollama, informar a URL http://localhost:11434 e escolher qwen3.5:9b na lista carregada automaticamente.
3. 03
   Escolher o motor de embeddings

   Próxima etapa: Embedder. Selecionar Ollama e o modelo nomic-embed-text. O AnythingLLM também pode usar seu embedder local integrado se você não tiver baixado nomic-embed-text — de qualidade inferior, mas sem necessidade de configuração.
4. 04
   Criar um workspace

   Na barra lateral: + New Workspace. Dar um nome ao workspace. Clicar nele e depois no ícone de upload para arrastar seus arquivos PDF, .docx, .csv, .epub, URLs ou até vídeos do YouTube (transcrição automática).
5. 05
   Mover documentos → workspace

   O AnythingLLM separa a ingestão (documentos listados à esquerda) do uso (workspace à direita). Selecionar os documentos, clicar em 'Move to Workspace' e depois em 'Save and Embed'. É nessa etapa que os embeddings são calculados via Ollama.
6. 06
   Conversar com citações

   No workspace, fazer sua pergunta. Cada resposta contém um painel expansível chamado Citations, que mostra exatamente quais chunks foram utilizados. Muito útil para verificar se o modelo não inventou informações.

Open WebUI

Melhor se você quer uma interface de uso geral semelhante à do ChatGPT, multiusuário (equipe), com acesso pela web. O RAG é uma funcionalidade entre outras.

AnythingLLM

Melhor se o RAG for o uso principal: workspaces com restrições rígidas, citações bem feitas, suporte a mais formatos (URL, YouTube, GitHub), agentes integrados.

#3. Qual modelo de embeddings escolher

O modelo de embeddings é o elemento que muitos deixam de lado. É ele que transforma seus documentos em vetores — sua qualidade condiciona diretamente a relevância dos trechos encontrados. Em documentos em francês, alguns modelos são claramente melhores que outros.

nomic-embed-text (137M, 274 MB)

A opção padrão recomendada. Rápido, com desempenho multilíngue razoável e contexto de 8192 tokens. Um ótimo equilíbrio para começar. Disponível diretamente: ollama pull nomic-embed-text.

mxbai-embed-large (335M, 670 MB)

Mais preciso que nomic, ligeiramente mais lento. Voltado principalmente ao inglês, mas também dá conta do francês em documentos comuns. Priorizar se a qualidade for mais importante que a velocidade. ollama pull mxbai-embed-large.

bge-m3 (567M, 1,2 GB)

Excelente em múltiplos idiomas (100+ idiomas, incluindo francês nativo), contexto 8192. Mais pesado. Disponível no Hugging Face, pode ser importado no Ollama via Modelfile.

snowflake-arctic-embed

Bom desempenho multilíngue, mais leve que bge-m3. Boa alternativa se o bge-m3 for muito pesado.

#4. RAG local em 4 GB de RAM, sem GPU

Sim, é possível. O RAG exige menos recursos do que se imagina: a maior parte do trabalho (embeddings) ocorre pontualmente durante a ingestão e, durante o uso, apenas o LLM responde com alguns milhares de tokens de contexto a mais. Em uma máquina pequena, a principal escolha envolve o LLM que gera as respostas.

4 GB de RAM, CPU lento (notebook antigo)

LLM: qwen3.5:2b ou granite4.2:3b em Q4_K_M (~2 GB). Embeddings: nomic-embed-text. Respostas lentas mas legíveis (3-5 tok/s). O contexto do LLM passa para 2048 para permanecer abaixo do limite de RAM.

8 GB de RAM, CPU recente (i5/Ryzen 5)

LLM: qwen3.5:4b Q4 (~3,4 GB) ou gemma4:e2b-it-qat. Embeddings: nomic-embed-text. ~6-10 tok/s. Essa é a configuração 'nada mal' sem GPU.

16 GB de RAM, sem GPU

LLM: granite4.2:8b ou qwen3.5:9b Q4 (~5-7 GB). Embeddings: nomic ou mxbai. ~4-8 tok/s usando apenas a CPU em um Ryzen 7 ou i7 recente.

# Petit LLM rapide, embeddings standards
ollama pull qwen3.5:2b
ollama pull nomic-embed-text

# Réduire le contexte pour économiser la RAM
# Dans Open WebUI : Settings → Models → qwen3.5 → num_ctx = 2048
# Dans AnythingLLM : Workspace settings → Max Tokens = 2048

# Vérifier l'usage RAM en pleine question :
ollama ps

#Solução de problemas

O modelo 'não vê' meus documentos

Verifique se a base de conhecimento está de fato associada ao chat (Open WebUI: comando #, AnythingLLM: ícone workspace). Verifique também se os documentos já foram convertidos em embeddings, e não apenas enviados.

Respostas muito lentas em modelos pequenos

O RAG adiciona 1000 a 3000 tokens ao contexto. Reduza o top-k (3 a 5 blocos em vez de 10) nos ajustes do RAG e reduza o num_ctx do LLM para 2048 ou 4096.

Alucinações apesar dos documentos

Aumente o top-k, verifique se o modelo de embedding é o mesmo que indexou (mudar de modelo invalida a base). Ative as citações para ver o que o LLM realmente leu.

Open WebUI não vê Ollama

No Docker, use --add-host=host.docker.internal:host-gateway e depois, em Settings → Connections, insira http://host.docker.internal:11434 como URL do Ollama.

AnythingLLM trava durante a geração de embeddings

Muitas vezes, é falta de RAM. Feche outros aplicativos, divida a importação em partes ou mude para um modelo de embeddings mais leve (nomic em vez de bge-m3).

#Para se aprofundar

Depois de configurar seu RAG local com Ollama, estes guias são próximos passos naturais para se aprofundar:

RAG local: introdução

O guia conceitual que explica o que acontece nos bastidores (chunking, embeddings, retrieval) — útil para entender por que funciona ou não.

Os melhores modelos de embeddings para francês

Comparativo detalhado BGE, E5, Solon para conteúdo francês — quando mudar de nomic-embed-text.

Open WebUI com Ollama: guia completo

Para ir além do RAG em Open WebUI: múltiplos usuários, perfis, prompts personalizados, pipelines.

Executar um LLM sem GPU

Guia detalhado CPU-only com benchmarks de tokens por segundo por CPU — se você quer otimizar seu setup RAG sem GPU.