Intermédiaire 22 minRAG

RAG en local avec ChromaDB et Ollama : tutoriel Python

RAG en local avec ChromaDB et Ollama : tutoriel Python

Faire du rag chromadb ollama python en local, c'est trois briques qui s'imbriquent : un vector store qui persiste sur disque (ChromaDB), un modèle d'embeddings qui transforme vos chunks en vecteurs (nomic-embed-text via Ollama), et un LLM de chat qui répond en s'appuyant sur les passages retrouvés. Pas de clé d'API, pas de fuite de données. Ce guide vous fait passer d'un PDF brut à un chatbot qui cite ses sources en 22 minutes.

Par Mohamed Meguedmi·Màj 2026-10-14·Testé sur Windows, macOS, Linux

#Pourquoi cette stack pour un RAG local

Beaucoup de tutos RAG commencent par LangChain ou LlamaIndex. Ces frameworks sont puissants mais cachent ce qui se passe sous le capot. Ici, on écrit le pipeline à la main avec trois dépendances seulement. Vous comprendrez chaque étape, et vous saurez quoi optimiser plus tard.

ChromaDB
Vector store open source, pur Python, mode persistant intégré (SQLite + index HNSW). Pas de serveur à lancer.
Ollama
Sert à la fois le modèle d'embeddings (nomic-embed-text) et le LLM de chat (Qwen 3.5, Granite 4.2, Gemma 4). Endpoint HTTP unique sur localhost:11434.
Python natif
Quelques fonctions, pas de framework. Vous pourrez brancher LangChain plus tard si besoin, mais ce n'est pas nécessaire pour démarrer.
i
Ce que vous obtenez
Un script Python d'environ 150 lignes qui ingère un dossier de PDF, les chunke, les indexe dans ChromaDB, et répond à des questions en français avec citations. Tout en local, zéro requête sortante.

#Prérequis

Le kit complet pour créer ton propre copilote IA.

Profite de notre expérience et d’un parcours guidé pour créer ton copilote local et prendre en main ton assistant de code.

  • Espace en ligne à vie
  • PDF + fichiers
  • Remboursé 30 j
Python 3.10+
ChromaDB demande 3.10 minimum. Vérifiez avec python --version.
Ollama installé et lancé
Le daemon écoute par défaut sur http://localhost:11434. Si vous partez de zéro, suivez d'abord le guide d'installation Ollama.
8 Go de RAM
16 Go confortables. Le modèle de chat 9B en Q4 prend ~6 Go, le modèle d'embeddings ~300 Mo.
Un GPU n'est pas obligatoire
L'inférence CPU fonctionne, juste plus lente. Pour l'ingestion d'un gros corpus, un GPU 6 Go+ accélère beaucoup les embeddings.

#1. Installer ChromaDB et préparer Ollama

On crée un environnement virtuel propre, on installe les trois libs nécessaires, et on télécharge les modèles côté Ollama.

Environnement Python
python -m venv .venv
source .venv/bin/activate  # sous Windows : .venv\Scripts\activate
pip install chromadb ollama pypdf

Trois paquets : chromadb pour le vector store, ollama pour le client Python officiel, pypdf pour lire les PDF. C'est tout.

Modèles Ollama
ollama pull nomic-embed-text:v1.5
ollama pull qwen3.5:9b

Le parcours utilise nomic-embed-text:v1.5 pour rendre explicites le modèle et ses préfixes de tâche. Il sert d'exemple de départ ; sur un corpus français, mesurez les résultats de recherche et comparez notamment BGE-M3. La qualité dépend aussi du découpage et des documents.

→
Vérifier qu'Ollama répond
Un simple curl http://localhost:11434/api/tags doit lister vos modèles. Si rien ne sort, le daemon n'est pas lancé : ollama serve dans un autre terminal.

#2. Configurer le modèle d'embeddings

Un embedding, c'est un vecteur qui représente le sens d'un texte. Deux textes proches sémantiquement ont des vecteurs proches. C'est le moteur du RAG : on cherche les chunks dont l'embedding ressemble le plus à celui de la question.

embed.py — test rapide
import ollama

resp = ollama.embed(
    model="nomic-embed-text:v1.5",
    input="search_document: Le contrat est résilié en cas de manquement grave.",
)
vec = resp["embeddings"][0]
print(f"Dimension du vecteur : {len(vec)}")
print(f"5 premières valeurs : {vec[:5]}")

Vous devriez voir Dimension du vecteur : 768. Si ça plante avec model not found, c'est que ollama pull nomic-embed-text n'a pas été fait.

i
Préfixes et cohérence de l’index
Nomic v1.5 demande search_document: devant chaque chunk et search_query: devant la question. Ne mélangez pas des vecteurs produits avec d'autres modèles, dimensions ou conventions dans une même collection. La fiche du modèle ne justifie pas un classement « top 5 en français » pour votre corpus.

#3. Ingestion de PDF en français

L'ingestion fait trois choses : lire les pages d'un PDF, découper le texte en chunks de taille raisonnable, et stocker chaque chunk avec son embedding dans ChromaDB en mode persistant.

ingest.py
import os
import chromadb
import ollama
from pypdf import PdfReader

client = chromadb.PersistentClient(path="./chroma_db")
# Nouveau nom : un ancien index "docs" peut encore utiliser la distance L2.
collection = client.get_or_create_collection(
    name="docs_nomic_v15_cosine",
    configuration={"hnsw": {"space": "cosine"}},
)

def chunk_text(text, size=800, overlap=100):
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + size, len(text))
        chunk = text[start:end].strip()
        if chunk:
            chunks.append(chunk)
        start += size - overlap
    return chunks

def ingest_pdf(path):
    reader = PdfReader(path)
    name = os.path.basename(path)
    # Ce dossier d'exemple suppose des noms de fichiers uniques.
    # Retire aussi les chunks devenus obsolètes si le PDF a été raccourci.
    collection.delete(where={"source": name})
    count = 0
    for page_num, page in enumerate(reader.pages):
        text = page.extract_text() or ""
        for i, chunk in enumerate(chunk_text(text)):
            emb = ollama.embed(
                model="nomic-embed-text:v1.5",
                input="search_document: " + chunk,
            )["embeddings"][0]
            collection.upsert(
                ids=[f"{name}-p{page_num}-c{i}"],
                embeddings=[emb],
                documents=[chunk],
                metadatas=[{"source": name, "page": page_num + 1}],
            )
            count += 1
    print(f"OK : {name} ({len(reader.pages)} pages, {count} chunks indexés)")

if __name__ == "__main__":
    for f in os.listdir("./pdfs"):
        if f.lower().endswith(".pdf"):
            ingest_pdf(f"./pdfs/{f}")

Le chunker découpe en blocs de 800 caractères avec 100 de chevauchement. C'est un point de départ : ni trop petit (manque de contexte) ni trop gros (dilue le signal). Pour du contenu juridique très dense, descendez à 500. Pour des manuels techniques aérés, montez à 1200.

→
Le mode persistant de ChromaDB
PersistentClient conserve la base sur disque. Le nouveau nom docs_nomic_v15_cosine évite de reprendre silencieusement l'ancien index L2. Si vous changez le modèle, ses préfixes, la dimension ou la distance, créez une nouvelle collection et réingérez les documents. Sauvegardez les PDF avant une réindexation : le script retire d'abord les anciens chunks du fichier.

Lancez l'ingestion sur un dossier ./pdfs/ contenant vos documents :

Lancer l'ingestion
mkdir -p pdfs
# placez vos PDF dans ./pdfs/
python ingest.py
!
PDF scannés = pas de texte
pypdf n'extrait que le texte natif. Si vos PDF sont des scans d'images, extract_text() renverra du vide. Il faut alors passer par un OCR (Tesseract, ou un modèle vision comme Qwen 3.5 9B, multimodal, via Ollama) avant l'ingestion.

#4. Recherche top-k dans ChromaDB

La collection ci-dessus choisit explicitement la distance cosinus, contrairement au réglage L2 par défaut. La question reçoit le préfixe search_query:, puis ChromaDB retrouve les passages les plus proches dans cet index. get_or_create_collection ne transforme pas un ancien index en changeant seulement son nom de variable.

search.py
import chromadb
import ollama

client = chromadb.PersistentClient(path="./chroma_db")
collection = client.get_collection(name="docs_nomic_v15_cosine")

def search(question, k=4):
    count = collection.count()
    if count == 0:
        return []
    q_emb = ollama.embed(
        model="nomic-embed-text:v1.5",
        input="search_query: " + question,
    )["embeddings"][0]
    results = collection.query(
        query_embeddings=[q_emb],
        n_results=min(k, count),
    )
    chunks = results["documents"][0]
    metas = results["metadatas"][0]
    return list(zip(chunks, metas))

if __name__ == "__main__":
    hits = search("Quelles sont les conditions de résiliation ?")
    for chunk, meta in hits:
        print(f"[{meta['source']} p.{meta['page']}]")
        print(chunk[:200], "...\n")

k=4 est un bon défaut. Trop petit, vous ratez du contexte pertinent ; trop grand, vous noyez le LLM dans du bruit et explosez la fenêtre de contexte. Pour des questions très précises, k=2 suffit. Pour des questions transversales, montez à 6.

#5. Boucle de chat avec citations

Maintenant on assemble : on cherche les chunks pertinents, on construit un prompt avec le contexte, on envoie à Qwen 3.5 via Ollama, et on demande au modèle de citer ses sources.

chat.py
import ollama
from search import search

SYSTEM = """Tu es un assistant qui répond uniquement à partir du CONTEXTE fourni.
Si la réponse n'est pas dans le contexte, dis-le clairement.
Cite tes sources entre crochets sous la forme [source.pdf p.X]."""

def ask(question):
    hits = search(question, k=4)
    if not hits:
        return "Aucun passage indexé disponible pour répondre."
    context = "\n\n".join(
        f"[{m['source']} p.{m['page']}]\n{c}" for c, m in hits
    )
    prompt = f"CONTEXTE :\n{context}\n\nQUESTION : {question}"
    resp = ollama.chat(
        model="qwen3.5:9b",
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": prompt},
        ],
        options={"temperature": 0.2, "num_ctx": 8192},
    )
    return resp["message"]["content"]

if __name__ == "__main__":
    while True:
        q = input("\nQuestion (vide pour quitter) > ").strip()
        if not q:
            break
        print("\n" + ask(q))

Le contexte num_ctx=8192 doit contenir les chunks, la question, les instructions et la réponse ; réduisez le nombre de passages si la mémoire manque. Le prompt demande des citations et une réponse fondée sur les documents, mais ne garantit pas l'absence d'hallucination : ouvrez les pages citées et vérifiez les affirmations.

→
Streaming pour une meilleure UX
Remplacez ollama.chat par ollama.chat(..., stream=True) et itérez sur la réponse pour afficher les tokens au fur et à mesure. C'est crucial dès qu'on intègre ce code dans une vraie interface (FastAPI + WebSocket, ou Streamlit).

#6. Exemple concret : chatbot juridique sur des contrats

Imaginons un cabinet qui veut interroger 200 contrats de prestation en PDF. Avec la stack ci-dessus, en moins d'une heure on a un assistant qui répond à des questions du type :

Question typique
« Quels contrats incluent une clause de non-concurrence post-rupture supérieure à 12 mois ? »
Ce qui se passe
L'embedding de la question retrouve les chunks qui contiennent les mots-clés sémantiquement proches (non-concurrence, post-rupture, durée). Qwen 3.5 lit ces 4 passages et répond avec les noms de fichiers concernés.
Garantie de confidentialité
Aucune donnée ne sort du poste. Pas de clé d'API. Aucune télémétrie. C'est ce qui distingue un RAG local d'un wrapper OpenAI.
!
Limites à connaître
Un RAG basique répond bien aux questions ciblées (« quelle est la clause X »), mal aux questions agrégatives (« combien de contrats ont X »). Pour ces dernières, il faut soit un agent qui interroge la base en plusieurs étapes, soit un GraphRAG. C'est une autre histoire.

#Dépannage

ChromaDB lent à l'ingestion
Mesurez le temps d'extraction PDF, de découpage, d'embedding et d'écriture séparément. Vérifiez le placement du modèle avec ollama ps. Aucun débit universel de 50 ou 500 chunks par seconde n'est établi par ce guide.
« model not found »
Ollama ne trouve pas nomic-embed-text. Relancez ollama pull nomic-embed-text et vérifiez avec ollama list.
Réponses qui inventent des sources
Un modèle 9B hallucine encore parfois. Passez à mistral-small (24B, ~14 Go, très bon en français) ou qwen3.8:27b si vous avez la VRAM. Ou ajoutez un reranker (cross-encoder) après ChromaDB pour filtrer les faux positifs.
Embeddings de mauvaise qualité en FR
Évaluez les passages récupérés sur des questions françaises dont vous connaissez les réponses. BGE-M3 est disponible directement avec ollama pull bge-m3. Si vous changez de modèle, réindexez dans une collection distincte ; les préfixes nomic ne doivent pas être repris automatiquement pour tous les modèles.
ChromaDB grossit sans limite
Le script mis à jour supprime les chunks du fichier avant sa réingestion et utilise des IDs stables avec upsert. Cela retire également les anciennes pages d'un PDF raccourci. Il reste un exemple local simple : conservez les documents d'origine et une sauvegarde de la base.

#Sources et vérification du 14 octobre 2026

Révision du 14 octobre 2026 : code vérifié avec un index ChromaDB réel pour le classement cosinus et un PDF de test pour la réingestion. Les appels d'embeddings de ce test utilisent un serveur de simulation local ; la qualité sémantique et la vitesse d'un modèle Ollama restent à mesurer sur votre corpus.

#Pour aller plus loin

Vous avez un RAG fonctionnel. Voici les chantiers naturels pour le pousser plus loin :

Comparer les modèles d'embeddings FR
Notre guide « Les meilleurs modèles d'embeddings FR » compare BGE, E5, Solon et nomic sur du contenu francophone.
Améliorer le chunking
« Stratégies de chunking » détaille le chunking sémantique, par titres markdown, ou par paragraphes — souvent ce qui débloque le plus de précision.
Ajouter un reranker
« Ajouter un reranker à son pipeline » : +15% de pertinence en plaçant un cross-encoder après Chroma. Le pas suivant logique.
Recherche hybride
« Recherche hybride BM25 + vectoriel » combine lexical et sémantique, indispensable dès qu'il y a beaucoup de jargon ou de noms propres.
Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.