RAG avec Ollama en Python : connectez vos documents à un LLM local

Ce que vous allez construire : un pipeline RAG complet — ingestion de documents, chunking, embeddings vectoriels, stockage ChromaDB, retrieval sémantique et génération avec Ollama — 100% local, zéro donnée envoyée en dehors de votre machine.

nomic-embed-text · ChromaDB · LangChain PDF · TXT · Markdown · HTML Réponses ancrées dans les sources

Pipeline RAG complet — phase d'ingestion (gauche) construite une fois, phase de requête (droite) exécutée à chaque question

pip install langchain langchain-community langchain-ollama langchain-chroma langchain-text-splitters chromadb pypdf

# Modèle de génération (LLM)
ollama pull mistral

# Modèle d'embedding — open source, 768 dimensions, surpasse ada-002 d'OpenAI
ollama pull nomic-embed-text

Pourquoi nomic-embed-text ? C'est le modèle d'embedding open source recommandé pour Ollama : 768 dimensions, surpasse text-embedding-ada-002 d'OpenAI sur les benchmarks court et long format. Note : la fenêtre de contexte dans Ollama est de 2 048 tokens — suffisant pour des chunks bien dimensionnés. Disponible directement depuis la bibliothèque Ollama, aucun compte externe requis.

from langchain_community.document_loaders import PyPDFLoader, TextLoader, DirectoryLoader

# Charger un PDF
loader = PyPDFLoader("contrat.pdf")
documents = loader.load()

# Charger tous les fichiers .txt d'un dossier
loader = DirectoryLoader("./docs/", glob="**/*.txt", loader_cls=TextLoader)
documents = loader.load()

# Charger tous les PDF d'un dossier
loader = DirectoryLoader("./docs/", glob="**/*.pdf", loader_cls=PyPDFLoader)
documents = loader.load()

print(f"{len(documents)} documents chargés")

from langchain_text_splitters import RecursiveCharacterTextSplitter

# Configuration recommandée (point de départ — ajustez selon vos docs)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,        # 512 caractères (≈ 80-120 mots selon la densité du texte)
    chunk_overlap=50,      # ~10% de chevauchement pour maintenir le contexte
    separators=["\n\n", "\n", ".", " ", ""]  # Priorité : paragraphe > phrase > mot
)

chunks = splitter.split_documents(documents)
print(f"{len(chunks)} chunks créés")

# Inspecter un chunk
print(chunks[0].page_content[:200])
print(chunks[0].metadata)  # {"source": "contrat.pdf", "page": 0}

Attention : chunk_size est en caractères, pas en tokens. RecursiveCharacterTextSplitter(chunk_size=512) découpe en segments de 512 caractères (≈ 80-120 mots). Pour un chunking vraiment basé sur le nombre de tokens (utile si vous voulez coller précisément aux limites de contexte), utilisez RecursiveCharacterTextSplitter.from_tiktoken_encoder(chunk_size=512) qui tokenise avec tiktoken avant de couper.

from langchain_ollama import OllamaEmbeddings

# Initialiser le modèle d'embedding (tourne via Ollama local)
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Tester sur un texte
vector = embeddings.embed_query("Quelle est la politique de congés ?")
print(f"Dimensions : {len(vector)}")  # 768

Important : le modèle d'embedding utilisé à l'ingestion doit être exactement le même à la requête. Mélanger les modèles produit des espaces vectoriels incompatibles et des résultats incohérents.

from langchain_chroma import Chroma

# Créer la base et indexer les chunks (première fois)
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db",   # Stockage persistant sur disque
    collection_name="mes_documents"
)

# Recharger une base existante (appels suivants)
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=embeddings,
    collection_name="mes_documents"
)

# Vérifier le nombre de documents indexés
print(f"{vectorstore._collection.count()} chunks indexés")

Persistance : le répertoire ./chroma_db contient toute la base vectorielle. L'ingestion (coûteuse en temps) se fait une seule fois. Les requêtes suivantes chargent simplement la base existante.

# Créer un retriever — récupère les 3 chunks les plus proches
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 3}
)

# Tester le retrieval directement
question = "Quelle est la politique de télétravail ?"
docs_retrieved = retriever.invoke(question)

for i, doc in enumerate(docs_retrieved):
    print(f"--- Chunk {i+1} (source: {doc.metadata.get('source', '?')}) ---")
    print(doc.page_content[:300])
    print()

from langchain_ollama import OllamaLLM
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_retrieval_chain

# LLM local
llm = OllamaLLM(model="mistral", temperature=0.1)  # temperature basse = réponses plus factuelles

# Prompt template — forcer l'ancrage dans le contexte
prompt = ChatPromptTemplate.from_template("""Tu es un assistant expert qui répond uniquement à partir des documents fournis.
Si la réponse n'est pas dans le contexte, dis-le explicitement — ne devine pas.

Contexte :
{context}

Question : {input}

Réponse (basée exclusivement sur le contexte ci-dessus) :""")

# Chaîne RAG — API LCEL (recommandée depuis LangChain 0.1+)
combine_docs_chain = create_stuff_documents_chain(llm, prompt)
rag_chain = create_retrieval_chain(retriever, combine_docs_chain)

# Poser une question
result = rag_chain.invoke({"input": "Quelle est la politique de télétravail ?"})
print(result["answer"])
print("\nSources :")
for doc in result["context"]:
    print(f"  - {doc.metadata.get('source')} (page {doc.metadata.get('page', '?')})")

"""
Pipeline RAG local — Ollama + LangChain + ChromaDB
Usage : python rag_pipeline.py
"""
import os
from pathlib import Path
from langchain_community.document_loaders import PyPDFLoader, DirectoryLoader, TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_ollama import OllamaEmbeddings, OllamaLLM
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_retrieval_chain

# --- Configuration ---
DOCS_DIR = "./docs"          # Dossier contenant vos documents
CHROMA_DIR = "./chroma_db"   # Stockage persistant ChromaDB
EMBED_MODEL = "nomic-embed-text"
LLM_MODEL = "mistral"
CHUNK_SIZE = 512
CHUNK_OVERLAP = 50
TOP_K = 3

# --- Initialisation ---
embeddings = OllamaEmbeddings(model=EMBED_MODEL)
llm = OllamaLLM(model=LLM_MODEL, temperature=0.1)

def ingest_documents() -> Chroma:
    """Charge, chunke et indexe tous les documents du dossier DOCS_DIR."""
    loaders = [
        DirectoryLoader(DOCS_DIR, glob="**/*.pdf", loader_cls=PyPDFLoader),
        DirectoryLoader(DOCS_DIR, glob="**/*.txt", loader_cls=TextLoader),
    ]
    documents = []
    for loader in loaders:
        try:
            documents.extend(loader.load())
        except Exception:
            pass

    splitter = RecursiveCharacterTextSplitter(
        chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP
    )
    chunks = splitter.split_documents(documents)
    print(f"Ingestion : {len(documents)} documents → {len(chunks)} chunks")

    return Chroma.from_documents(
        documents=chunks, embedding=embeddings,
        persist_directory=CHROMA_DIR, collection_name="rag_docs"
    )

def load_vectorstore() -> Chroma:
    """Recharge une base existante sans ré-ingérer."""
    return Chroma(
        persist_directory=CHROMA_DIR,
        embedding_function=embeddings,
        collection_name="rag_docs"
    )

def build_rag_chain(vectorstore: Chroma):
    prompt = ChatPromptTemplate.from_template(
        """Tu es un assistant qui répond uniquement à partir des documents fournis.
Si la réponse est absente du contexte, indique-le clairement.

Contexte :
{context}

Question : {input}

Réponse :"""
    )
    combine_docs_chain = create_stuff_documents_chain(llm, prompt)
    return create_retrieval_chain(
        vectorstore.as_retriever(search_kwargs={"k": TOP_K}),
        combine_docs_chain
    )

if __name__ == "__main__":
    # Ingestion si la base n'existe pas encore, sinon rechargement
    if not Path(CHROMA_DIR).exists():
        vectorstore = ingest_documents()
    else:
        vectorstore = load_vectorstore()
        print(f"Base chargée : {vectorstore._collection.count()} chunks")

    chain = build_rag_chain(vectorstore)

    # Boucle interactive
    print("\nRAG prêt. Posez vos questions (Ctrl+C pour quitter)\n")
    while True:
        question = input("Question : ")
        result = chain.invoke({"input": question})
        print(f"\nRéponse : {result['answer']}")
        print("Sources :", [d.metadata.get('source') for d in result['context']])
        print()

Stratégie	Taille indicative	Idéal pour	Limite
RecursiveCharacter (défaut)	512 car. (défaut) ou 512 tokens via from_tiktoken_encoder	Textes généraux, contrats, docs internes	Peut couper au milieu d'une idée complexe
Fixed size	256–1024 car. (ou tokens avec splitter dédié)	Datasets homogènes, code, logs	Ignore la structure sémantique
Par page (PDF)	1 page = 1 chunk	PDFs avec structure de pages significative	Pages longues = embeddings trop génériques
Parent-child	Child : 100t / Parent : 512t	Recherche précise + contexte riche	Plus complexe à implémenter
Markdown / HTML headers	Par section	Documentation technique structurée	Sections trop longues non gérées automatiquement

Le paradoxe du chunking : pour la recherche, de petits chunks (100-256 tokens) donnent une meilleure précision sémantique. Pour la génération, le LLM a besoin de contexte large (512+ tokens). La technique parent-child chunking résout ce paradoxe : on indexe de petits chunks, mais on récupère leurs parents plus larges pour la génération.

Critère	RAG	Fine-tuning
Données qui changent souvent	Idéal	Réentraînement requis
Réduction des hallucinations	Réduit (ancrage sources)	Amélioration limitée
Style/format de réponse imposé	Prompt engineering	Encodé dans les poids
Données privées / sensibles	Restent hors du modèle	Encodées dans les poids
Coût de mise en place	Faible (quelques heures)	Élevé (GPU + données)
Comportement spécialisé (ton, domaine)	Limité au prompt	Profond et stable

En pratique (2026) : la plupart des systèmes de production combinent les deux. Fine-tuning pour la consistance de format et le ton de marque, RAG pour la connaissance dynamique et la réduction des hallucinations. Commencez toujours par le RAG — c'est plus rapide à déployer et couvre 80% des cas d'usage.

Peut-on utiliser autre chose que ChromaDB ?

Oui. LangChain supporte de nombreuses bases vectorielles : FAISS (en mémoire, idéal pour les petits projets), Qdrant (performances et scalabilité), Weaviate (graphe + vecteur), Milvus (enterprise). ChromaDB est recommandé pour débuter car il ne requiert aucune infrastructure externe et persiste automatiquement sur disque.

Comment améliorer la qualité de récupération ?

Plusieurs techniques avancées : Hybrid Search (combinaison similarité cosinus + BM25 lexical via Reciprocal Rank Fusion), re-ranking (passer les top-100 résultats dans un cross-encoder pour ne garder que les top-5), parent-child chunking (embed petits chunks, récupère les parents). Ces techniques sont importantes en production mais complexifient le pipeline — maîtrisez d'abord la version simple.

Le RAG fonctionne-t-il avec des documents en français ?

Oui pour le français, avec nuances. nomic-embed-text (v1) est principalement entraîné sur de l'anglais — il fonctionne en français mais sans garantie de qualité benchmark. Pour un usage multilingue sérieux, préférez nomic-embed-text-v2-moe (disponible sur Ollama) : architecture MoE, ~100 langues, dimensions flexibles 256-768. Le LLM de génération (Mistral 7B, Llama 3.1) gère le français nativement.

Combien de temps prend l'ingestion ?

Sur un GPU RTX 4070 avec nomic-embed-text : environ 100-200 chunks/seconde. Un document de 50 pages (~500 chunks) s'indexe en 3-5 secondes. 1 000 documents PDF = 15-30 minutes selon la densité. L'ingestion se fait une seule fois — les requêtes suivantes chargent simplement la base existante en <1 seconde.

Par où commencer : créez un dossier ./docs, copiez-y 3-4 documents PDF, lancez le pipeline complet ci-dessus. Posez des questions sur le contenu — si le retrieval retourne les bons passages, votre pipeline fonctionne. Optimisez ensuite le chunking et le prompt selon vos cas d'usage spécifiques.

Articles liés