Accueil › Blog › RAG local avec Ollama
📚 Guide complet

RAG local avec Ollama : donnez une mémoire à votre IA

Guide complet 2026 avec démo interactive

avril 2026 • 18 min de lecture

« Imaginez un étudiant qui passe un examen. Sans RAG, c'est un examen à livre fermé — l'IA ne sait que ce qu'elle a mémorisé. Avec RAG, c'est un examen à livre ouvert — l'IA consulte vos documents avant de répondre. La différence est énorme. »

Le RAG (Retrieval Augmented Generation) est la technique la plus puissante pour donner à une IA locale accès à vos propres documents. Vos PDF, vos notes, votre code, vos mails — tout devient interrogeable en langage naturel. Et le meilleur : tout reste sur votre machine. Zéro donnée envoyée dans le cloud.

Dans ce guide, nous allons construire un système RAG complet en 5 étapes, avec Ollama pour le LLM, ChromaDB pour la base vectorielle, et LangChain pour orchestrer le tout. Chaque étape est accompagnée de code Python fonctionnel que vous pouvez copier-coller.

Testez notre démo interactive plus bas pour voir le RAG en action avant même de coder quoi que ce soit.

Nouveau : si vos documents vivent déjà dans Paperless, Nextcloud ou vos emails, lisez aussi notre guide dédié RAG local Paperless / Nextcloud / emails.
Avant d'indexer vos documents, vérifiez le modèle Un modèle trop gros pour la machine rend tout le RAG pénible. Local Cockpit, notre application Rust gratuite pour Windows et Linux, mesure sur votre PC la vitesse réelle du modèle qui répondra : vous construisez votre RAG sur un modèle qui tient la charge. Télécharger Local Cockpit

📚 Qu'est-ce que le RAG ?

RAG signifie Retrieval Augmented Generation — en français, "génération augmentée par la recherche". L'idée est simple : au lieu de demander à l'IA de tout savoir par cœur, on lui donne accès à une base de documents qu'elle peut consulter avant de répondre.

✗ Sans RAG (examen livre fermé)
  • • L'IA ne connaît que ses données d'entraînement
  • • Impossible de répondre sur vos documents privés
  • • Hallucinations fréquentes sur les sujets spécifiques
  • • Données figées à la date de coupure
✓ Avec RAG (examen livre ouvert)
  • • L'IA consulte vos documents avant de répondre
  • • Réponses précises et sourcées
  • • Réduction massive des hallucinations
  • • Toujours à jour (vos documents évoluent)

⚙️ Architecture d'un système RAG

Voici le pipeline complet, de vos documents bruts jusqu'à la réponse de l'IA :

📄 Documents
→
✂ Chunks
→
🔢 Embeddings
→
🗃 Vector DB
→
🔍 Query
→
🤖 LLM
→
✓ Réponse
Phase d'indexation (une seule fois) :

Vos documents sont découpés en morceaux (chunks), convertis en vecteurs numériques (embeddings) et stockés dans une base de données vectorielle.

Phase de requête (chaque question) :

Votre question est convertie en vecteur, les chunks les plus proches sont retrouvés, puis envoyés au LLM avec la question pour générer une réponse contextuelle.

🛠️ Étape 1 : Installer Ollama + modèles

Nous avons besoin de deux modèles : un LLM pour générer les réponses et un modèle d'embedding pour convertir le texte en vecteurs. Consultez notre guide d'installation Ollama si ce n'est pas encore fait.

# Installer Ollama (Linux/WSL)
curl -fsSL https://ollama.com/install.sh | sh
# Télécharger le LLM (génération de réponses)
ollama pull qwen3:8b
# Télécharger le modèle d'embedding (vectorisation)
ollama pull nomic-embed-text

💡 nomic-embed-text est un bon point de départ : léger (environ 270 Mo) et très répandu, mais entraîné surtout sur l'anglais. Pour des documents en français, comparez avec un modèle d'embedding multilingue (plus de 100 langues selon leurs fiches Ollama) : bge-m3 (1,2 Go) ou qwen3-embedding:0.6b (639 Mo). Changer de modèle d'embedding impose de réindexer vos documents.

🗃 Étape 2 : Installer ChromaDB

ChromaDB est une base de données vectorielle légère, parfaite pour débuter. Elle stocke vos embeddings et permet de retrouver les passages les plus pertinents en quelques millisecondes.

# Installer les dépendances
pip install chromadb langchain langchain-community
pip install pypdf docx2txt unstructured
# Vérifier l'installation
python -c "import chromadb; print(chromadb.__version__)"

ChromaDB fonctionne en mode embarqué (pas besoin de serveur séparé). Les données sont stockées localement sur votre SSD. Pour des collections massives (100k+ documents), un SSD NVMe rapide est recommandé.

📄 Étape 3 : Charger vos documents

LangChain fournit des loaders pour tous les formats courants. Voici comment charger un dossier contenant des PDF, fichiers texte, Markdown et code source :

# load_documents.py
from
langchain_community.document_loaders
import
(
DirectoryLoader, PyPDFLoader,
TextLoader, UnstructuredMarkdownLoader
)
# Charger tous les PDF d'un dossier
pdf_loader = DirectoryLoader(
"./mes_documents/",
glob="**/*.pdf",
loader_cls=PyPDFLoader
)
# Charger les fichiers texte et Markdown
txt_loader = DirectoryLoader(
"./mes_documents/",
glob="**/*.{txt,md}",
loader_cls=TextLoader
)
# Fusionner tous les documents
documents = pdf_loader.load() + txt_loader.load()
print(f"{len(documents)} documents chargés")

💡 Astuce : pour le code source (Python, JavaScript, etc.), utilisez TextLoader avec les extensions .py, .js, .ts. Le RAG fonctionne aussi pour interroger votre codebase !

✂ Étape 4 : Découper, vectoriser, stocker

C'est l'étape clé : chaque document est découpé en morceaux (chunks), chaque chunk est converti en vecteur numérique (embedding), puis stocké dans ChromaDB.

# index_documents.py
from
langchain.text_splitter
import
RecursiveCharacterTextSplitter
from
langchain_community.embeddings
import
OllamaEmbeddings
from
langchain_community.vectorstores
import
Chroma
# Découper en chunks
splitter = RecursiveCharacterTextSplitter(
chunk_size=1000, # 1000 caractères par chunk
chunk_overlap=200, # 200 caractères de chevauchement
separators=["\n\n", "\n", " ", ""]
)
chunks = splitter.split_documents(documents)
print(f"{len(chunks)} chunks créés")
# Créer les embeddings avec Ollama
embeddings = OllamaEmbeddings(
model="nomic-embed-text"
)
# Stocker dans ChromaDB (persisté sur disque)
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=embeddings,
persist_directory="./chroma_db"
)
print("Base vectorielle créée avec succès !")

💡 Optimiser les paramètres de chunking

Paramètre Valeur Explication
chunk_size 500-1500 Trop petit = contexte perdu. Trop grand = bruit dans les résultats. 1000 est un bon défaut.
chunk_overlap 100-300 Le chevauchement évite de couper une idée en deux. 20% du chunk_size est idéal.
top_k 3-5 Nombre de chunks retournés par requête. 3 est suffisant, 5 pour plus de contexte.

🔍 Étape 5 : Interroger vos documents

Tout est en place. Voici le code final pour poser une question et obtenir une réponse contextuelle :

# query_rag.py
from
langchain_community.llms
import
Ollama
from
langchain_community.embeddings
import
OllamaEmbeddings
from
langchain_community.vectorstores
import
Chroma
from
langchain.chains
import
RetrievalQA
from
langchain.prompts
import
PromptTemplate
# Charger la base vectorielle existante
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma(
persist_directory="./chroma_db",
embedding_function=embeddings
)
# Configurer le LLM local
llm = Ollama(model="qwen3:8b", temperature=0.1)
# Prompt personnalisé en français
prompt = PromptTemplate(
template="""Tu es un assistant qui répond
en français en utilisant UNIQUEMENT le
contexte fourni. Si tu ne trouves pas la
réponse, dis-le honnêtement.
Contexte: {context}
Question: {question}
Réponse:""",
input_variables=["context", "question"]
)
# Créer la chaîne RAG
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(
search_kwargs={"k": 3}
),
chain_type_kwargs={"prompt": prompt}
)
# Poser une question
question = "Quelles sont les conditions du contrat client Dupont ?"
result = qa_chain.invoke({"query": question})
print(result["result"])

Et voilà ! Votre IA locale peut maintenant répondre à n'importe quelle question en se basant sur vos propres documents. Pas de cloud, pas d'abonnement, pas de fuite de données. Tout reste sur votre machine.

🎮 Démo interactive : RAG en action

Tapez une question ci-dessous et observez le processus RAG en temps réel : recherche dans les documents, récupération des passages pertinents, puis génération de la réponse.

Simulateur RAG local

Essayez :
Documents
247
Chunks indexés
1842
Statut
$ rag-terminal v1.0 — en attente d'une question...

⚡ Conseils de performance

💾 Stockage (SSD NVMe)

ChromaDB stocke les embeddings sur disque. Un SSD, idéalement NVMe, accélère nettement le chargement et la recherche par rapport à un disque dur. Pour 100k+ documents, c'est indispensable.

🧠 RAM système

ChromaDB charge ses index en mémoire. La RAM nécessaire dépend du nombre de chunks, de la dimension des vecteurs et de l'index, pas du nombre de fichiers : indexez un échantillon, mesurez la consommation, puis extrapolez.

🎬 GPU (VRAM)

Le LLM tourne sur GPU, à côté du modèle d'embedding. 8 Go VRAM = modèles 7-8B. 12 Go = jusqu'à 12-14B. 24 Go = 27-32B pour des réponses plus précises.

🔧 Chunk size optimal

Règle empirique : chunk_size = 1000 pour du texte général, 500 pour du code, 1500 pour des documents juridiques. Testez et ajustez !

💻 Matériel requis pour le RAG local

Voici les configurations recommandées selon votre volume de documents. Vérifiez aussi si votre PC actuel peut faire tourner l'IA locale.

Composant Minimum Recommandé Optimal
GPU RTX 3060 12 Go RTX 4070 Ti Super RTX 4090 24 Go
RAM 16 Go 32 Go DDR5 64 Go DDR5
SSD SSD SATA 500 Go NVMe 1 To NVMe Gen4 2 To
Documents Petit corpus personnel Corpus d'équipe Très gros corpus (à mesurer)

💡 Pas de GPU ? Consultez notre guide upgrade IA pour assembler un PC adapté au RAG. Vous pouvez aussi tester si votre PC actuel est compatible.

Questions fréquentes

Plusieurs dizaines de milliers de documents restent courants avec ChromaDB sur une machine de bureau. La limite pratique dépend du nombre de chunks, de la taille des vecteurs et de l'index, donc de votre RAM et de votre SSD : indexez un échantillon et mesurez. Pour des collections très larges (100k+), envisagez Qdrant ou Milvus et davantage de RAM.
Oui, à condition de choisir les bons modèles. nomic-embed-text a été entraîné surtout sur l'anglais : pour des documents en français, préférez un modèle d'embedding multilingue comme bge-m3 ou qwen3-embedding. Pour le LLM, les modèles multilingues récents (Qwen3, Gemma 4, Mistral Small 3.2) sont de meilleurs points de départ que Mistral 7B, qui date de mai 2024 et reste une option légère. Testez-les sur vos propres documents.
Le RAG donne accès à des documents externes sans modifier le modèle — c'est comme donner un livre à un étudiant. Le fine-tuning modifie le modèle lui-même — c'est comme former l'étudiant sur un sujet. Le RAG est plus simple, plus flexible (documents mis à jour instantanément), et ne nécessite pas de GPU puissant pour l'entraînement. Dans la plupart des cas, le RAG suffit.
Oui pour vos documents. Avec Ollama en local, le LLM et le modèle d'embedding tournent sur votre machine. ChromaDB stocke les données sur votre disque dur. Aucune connexion internet n'est nécessaire après l'installation initiale : vos documents ne quittent pas votre ordinateur. Pour en avoir le cœur net, coupez le réseau et vérifiez que tout fonctionne. Pour en savoir plus, consultez notre guide RAG sans internet.
Mesurez sur votre vraie machine Scan CPU/GPU/VRAM, Ollama, modèle compatible, benchmark tokens/s. Gratuit, sans vente forcée. Télécharger Local Cockpit Estimer mon PC
À lire ensuite
Hub IA locale Preuves Local Cockpit Machine puis orchestre Installer Ollama Ollama vs LM Studio

Articles liés

Ollama + Docker : déployer une IA locale proprement en 2026