Points clés
- RAG = télécharger des documents + laisser le modèle répondre à des questions à ce sujet, en citant les sources.
- Open WebUI dispose du RAG intégré le plus facile. Téléchargez un PDF, posez des questions. Configuration en 5 minutes.
- LlamaIndex est le framework le plus flexible pour construire des pipelines RAG.
- LangChain est le framework professionnel le plus largement utilisé, avec un écosystème massif.
- Chroma et Qdrant sont les principales bases de données vectorielles pour stocker les chunks de documents.
- En avril 2026, RAG local est mature et prêt pour la production.
Qu'est-ce que RAG (Retrieval-Augmented Generation)?
RAG est une technique qui permet à votre LLM de répondre à des questions sur vos propres documents sans avoir besoin de affiner le modèle.
Le processus: (1) Téléchargez vos documents (PDFs, fichiers texte), (2) divisez-les en chunks, (3) convertissez les chunks en embeddings (vecteurs numériques), (4) stockez les embeddings dans une base de données vectorielle, (5) quand vous posez une question, récupérez les chunks pertinents de la base de données, (6) passez les chunks + question au LLM, (7) le LLM répond en fonction des chunks.
RAG est préféré à l'affinage quand vos documents changent fréquemment (l'affinage est un entraînement ponctuel), et vous avez besoin d'attribution de source (RAG montre quels documents ont été utilisés).
Meilleurs 8 outils RAG locaux en 2026
| Outil | Type | Idéal pour | Base de données vectorielle | Courbe d'apprentissage |
|---|---|---|---|---|
| Open WebUI | Application web (Docker) | Débutants, configuration la plus facile | Intégrée | Aucune |
| LlamaIndex | Framework Python | Pipelines flexibles | N'importe laquelle (Chroma, Qdrant, Pinecone) | Moyenne |
| LangChain | Framework Python | Systèmes de production | N'importe laquelle | Moyenne |
| Chroma | Base de données vectorielle | RAG simple | Chroma (intégrée) | Faible |
| Qdrant | Base de données vectorielle | RAG scalable | Qdrant (distribuée) | Moyenne |
| Weaviate | Base de données vectorielle | Requêtes GraphQL | Weaviate | Moyenne |
| Milvus | Base de données vectorielle | Grande échelle | Milvus | Élevée |
| Text-Generation-WebUI RAG | Extension | Intégré avec le modèle | Intégrée | Faible |
Comment utiliser Open WebUI RAG (le plus facile)?
Open WebUI dispose du RAG intégré. Aucune configuration au-delà de Docker. Téléchargez simplement des documents et posez des questions.
# 1. Exécuter Open WebUI avec Docker
docker run -d -p 3000:8080 \
-e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
ghcr.io/open-webui/open-webui:latest
# 2. Ouvrez http://localhost:3000
# 3. Cliquez sur "+" à côté de l'entrée de message → "Télécharger des fichiers"
# 4. Sélectionnez les PDFs ou fichiers texte
# 5. Posez des questions -- Open WebUI récupère les chunks pertinents
# 6. Le modèle répond en fonction des documents, avec citationsComment construire RAG avec LlamaIndex?
LlamaIndex est un framework qui gère le chargement de documents, le chunking, l'embedding et la récupération. Flexible, supporte n'importe quelle base de données vectorielle.
# 1. Installer
pip install llama-index
pip install llama-index-embeddings-ollama # utiliser les embeddings Ollama locaux
pip install llama-index-vector-stores-chroma # utiliser Chroma pour le stockage
# 2. Pipeline RAG simple
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.embeddings.ollama import OllamaEmbedding
# Charger les documents
documents = SimpleDirectoryReader("./documents").load_data()
# Créer l'index avec les embeddings locaux
embedding_model = OllamaEmbedding(model_name="nomic-embed-text")
index = VectorStoreIndex.from_documents(
documents,
embed_model=embedding_model
)
# Requête
query_engine = index.as_query_engine()
response = query_engine.query("Que dit le document sur X?")
print(response)Comment construire RAG avec LangChain?
LangChain est le framework le plus largement utilisé pour les systèmes RAG de production. Supporte toutes les bases de données vectorielles et fournisseurs 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
# Charger les documents
loader = DirectoryLoader("./documents")
docs = loader.load()
# Diviser en chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
chunks = splitter.split_documents(docs)
# Créer les embeddings et le vector store
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(chunks, embeddings)
# Créer la chaîne QA
llm = ChatOllama(model="llama3.2:8b")
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever()
)
# Répondre aux questions
result = qa.run("Que dit le document sur X?")
print(result)Quelles bases de données vectorielles sont les meilleures pour RAG local?
Chroma (la plus facile): Base de données vectorielle en processus. Aucune configuration de serveur. Parfaite pour les petits projets RAG (< 1M documents).
Qdrant (scalable): Auto-hébergée ou cloud. Meilleure pour RAG à grande échelle. Plus de fonctionnalités que Chroma.
Weaviate: Basée sur GraphQL. Bonne pour les requêtes complexes sur les embeddings.
Milvus: Classe entreprise. Pour RAG à très grande échelle (100M+ documents).
Pour la plupart des déploiements locaux, Chroma est suffisant et le plus facile.
Devriez-vous utiliser RAG ou l'affinage?
Utilisez ce cadre:
- Utilisez RAG si: Vos documents changent fréquemment, vous avez besoin d'attribution de source, vous voulez zéro entraînement de modèle, ou vous avez moins de 100K documents.
- Utilisez l'affinage si: Votre base de connaissances est fixe, vous voulez que le modèle "comprenne" réellement le domaine, ou vous avez besoin de vitesse d'inférence (les modèles affinés sont plus rapides).
- Combinez les deux: Affinez un modèle sur votre domaine, puis ajoutez RAG par-dessus pour une Q&A de très haute qualité.
Erreurs courantes avec RAG local
- Utiliser la mauvaise taille de chunk. Trop petit (100 tokens) = trop de petits morceaux. Trop grand (2000 tokens) = pas spécifique. Optimal est 500-1000 tokens.
- Oublier d'utiliser les embeddings. Vous ne pouvez pas faire de RAG sans convertir les chunks en embeddings. Utilisez `nomic-embed-text` (meilleur pour l'anglais) ou `bge-m3` (multilingue).
- Ne pas évaluer la qualité de la récupération. Juste parce que RAG s'exécute ne signifie pas qu'il récupère les bons documents. Testez avec des questions connues et vérifiez que les chunks récupérés sont pertinents.
- Traiter RAG comme un remplacement de l'affinage. RAG est récupération + apprentissage en contexte. L'affinage est une véritable adaptation de modèle. Outils différents pour différents emplois.
Questions courantes sur RAG local
Combien de documents RAG local peut-il gérer?
Dépend de la base de données vectorielle. Chroma gère 100K-1M documents facilement sur du matériel grand public. Au-delà de 1M, utilisez Qdrant ou Milvus.
RAG peut-il fonctionner avec des images?
Seulement si vous extrayez d'abord du texte (OCR). Pour la compréhension réelle des images, utilisez des modèles multimodaux comme Llama 3.2 Vision avec RAG.
RAG est-il plus lent que l'affinage?
RAG nécessite la récupération (millisecondes) plus le passage du contexte (tokens ajoutés au prompt). Généralement plus lent que l'inférence affinée mais beaucoup plus rapide à mettre en place.
Puis-je utiliser des embeddings cloud avec des LLMs locaux?
Oui. Utilisez des embeddings cloud (OpenAI, Cohere) pour la récupération et des LLMs locaux pour les réponses. L'approche hybride est courante.
Sources
- Documentation LlamaIndex -- docs.llamaindex.ai
- Documentation LangChain -- python.langchain.com
- Documentation Chroma -- docs.trychroma.com
- Documentation Qdrant -- qdrant.tech/documentation
- Papier RAG -- arxiv.org/abs/2005.11401