RAG LangChain : construire un chatbot documentaire local avec Ollama, Mistral et Python

Un chatbot RAG LangChain est un assistant qui répond à partir de vos propres documents : il recherche les passages pertinents dans une base vectorielle, les transmet à un modèle de langage, et ce dernier formule une réponse fondée sur ces extraits. Avec Ollama, tout fonctionne en local, sans clé d’API payante ni envoi de données vers le cloud.

Ce tutoriel s’adresse aux développeurs, aux profils techniques et aux curieux qui connaissent les bases de Python. Vous allez construire, étape par étape, un chatbot capable d’interroger un dossier de PDF avec Mistral en local : préparation de l’environnement, ingestion des documents, chaîne RAG avec LangChain, puis interface web.

Qu’est-ce que le RAG avec LangChain ?

Le RAG (Retrieval-Augmented Generation) est une architecture qui combine un moteur de recherche sémantique et un modèle de langage. À chaque question, le système retrouve les extraits de documents les plus proches par le sens, puis demande au modèle de répondre en s’appuyant uniquement sur ces extraits. LangChain est le framework Python qui assemble ces briques.

Pourquoi ne pas simplement coller vos documents dans le prompt ? Parce que la fenêtre de contexte d’un modèle est limitée, surtout en local, et qu’un modèle noyé sous des centaines de pages répond moins bien. Le RAG ne transmet que les quelques passages utiles à chaque question.

Un pipeline RAG comporte deux phases :

1. L’ingestion (une fois, puis à chaque mise à jour) : charger les documents, les découper en morceaux, calculer un vecteur (embedding) pour chaque morceau et stocker le tout dans une base vectorielle.
2. La génération (à chaque question) : transformer la question en vecteur, rechercher les morceaux les plus proches, les insérer dans le prompt et laisser le modèle rédiger la réponse.

Pourquoi construire un chatbot RAG en local ?

• Confidentialité : contrats, procédures internes, dossiers techniques ou données clients restent sur votre machine.
• Coût maîtrisé : pas de facturation au token, vous pouvez réindexer et tester sans compter.
• Réponses sourcées : le chatbot peut indiquer le document et la page d’où provient chaque information.
• Données à jour : il suffit de réindexer un document modifié, sans réentraîner le moindre modèle.
• Cas d’usage variés : assistant RH sur la convention collective, support client sur la documentation produit, aide à la recherche dans des rapports, base de connaissances technique.

Le choix de Mistral en local est pertinent pour un public francophone : les modèles de Mistral AI se débrouillent bien en français, et leurs versions de taille moyenne tournent sur un ordinateur récent.

Embeddings et base vectorielle : comment fonctionne la recherche ?

La partie « retrieval » du RAG repose sur une notion clé : l’embedding. Un modèle d’embeddings transforme un texte en une longue liste de nombres (un vecteur) qui représente son sens. Deux textes qui parlent de la même chose, même avec des mots différents, obtiennent des vecteurs proches.

Concrètement, la question « Combien de jours de télétravail sont autorisés ? » sera rapprochée d’un passage intitulé « Modalités du travail à distance », alors qu’une recherche par mots-clés classique l’aurait manqué. C’est ce qui rend le RAG efficace sur des documents rédigés dans un vocabulaire différent de celui des utilisateurs.

La base vectorielle stocke ces vecteurs avec le texte d’origine et ses métadonnées (nom du fichier, page). À chaque question, elle calcule le vecteur de la question et renvoie les morceaux dont les vecteurs sont les plus proches. Dans ce tutoriel, nous utilisons Chroma, une base légère qui s’enregistre dans un simple dossier du projet, idéale pour débuter. D’autres solutions existent pour des volumes plus importants ou un usage en production, et LangChain permet de passer de l’une à l’autre en changeant quelques lignes.

Trois conséquences pratiques en découlent :

• le même modèle d’embeddings doit servir à l’ingestion et aux questions, sinon les vecteurs ne sont pas comparables ;
• la qualité du modèle d’embeddings influence directement la pertinence des passages retrouvés, notamment en français ;
• la base ne contient que ce que vous y avez indexé : un document oublié à l’ingestion est invisible pour le chatbot.

Côté génération, le modèle de chat ne « lit » jamais toute votre base. Il ne reçoit que les quelques morceaux sélectionnés, insérés dans le prompt. C’est pourquoi un modèle local de taille moyenne suffit souvent : son travail se limite à reformuler et synthétiser des extraits pertinents, pas à tout savoir.

Comment créer un chatbot RAG avec LangChain et Ollama : les étapes

Étape 1 — Installer Ollama et les modèles

Si Ollama n’est pas encore installé, notre guide pour installer Ollama et faire tourner une IA locale détaille la procédure sur Windows, macOS et Linux. Téléchargez ensuite deux modèles : un modèle de chat et un modèle d’embeddings.

ollama pull mistral
ollama pull nomic-embed-text

Le premier rédige les réponses. Le second, beaucoup plus léger, transforme les textes en vecteurs numériques pour la recherche sémantique. Testez rapidement le modèle de chat :

ollama run mistral "Explique le principe du RAG en deux phrases."

Étape 2 — Préparer l’environnement Python

Vérifiez votre version de Python, puis créez un environnement virtuel pour isoler les dépendances du projet :

python --version
mkdir chatbot-rag && cd chatbot-rag
python -m venv .venv

Activez-le :

# Windows (PowerShell)
.venv\Scripts\activate
# macOS / Linux
source .venv/bin/activate

Installez ensuite les bibliothèques nécessaires :

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

Créez un dossier docs et placez-y quelques PDF. Pour un premier test, trois à dix documents suffisent. Si vous avez besoin de revoir les fondamentaux du langage (listes, boucles, fonctions, modules), notre guide pour apprendre Python vous remettra à niveau.

Un mot sur les clés d’API : ce projet 100 % local n’en utilise aucune. Si vous décidez plus tard de brancher un modèle en ligne, stockez la clé dans un fichier .env exclu de votre dépôt Git, jamais en clair dans le code.

Étape 3 — Tester LangChain avec Ollama

Avant de construire le RAG, vérifiez que LangChain communique bien avec Ollama. Créez un fichier test_llm.py :

from langchain_ollama import ChatOllama

llm = ChatOllama(model="mistral", temperature=0.2)
reponse = llm.invoke("Donne trois conseils pour rédiger une procédure interne claire.")
print(reponse.content)

Lancez-le avec python test_llm.py. Si une réponse s’affiche, la connexion fonctionne. Le paramètre temperature règle la créativité : une valeur basse donne des réponses plus stables et factuelles, ce que l’on recherche dans un RAG.

Étape 4 — Ingérer les documents

Le script d’ingestion charge les PDF, les découpe et les indexe dans une base vectorielle Chroma enregistrée sur le disque. Créez ingest.py :

from pathlib import Path

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_ollama import OllamaEmbeddings
from langchain_chroma import Chroma

DOCS_DIR = Path("docs")
DB_DIR = "chroma_db"

# 1. Charger toutes les pages de tous les PDF
documents = []
for pdf in DOCS_DIR.glob("*.pdf"):
    documents.extend(PyPDFLoader(str(pdf)).load())

# 2. Découper en morceaux qui se chevauchent légèrement
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
chunks = splitter.split_documents(documents)

# 3. Calculer les embeddings et les stocker dans Chroma
embeddings = OllamaEmbeddings(model="nomic-embed-text")
Chroma.from_documents(chunks, embedding=embeddings, persist_directory=DB_DIR)

print(f"{len(documents)} pages chargées, {len(chunks)} morceaux indexés.")

Lancez python ingest.py. Trois paramètres méritent votre attention :

• chunk_size : la taille des morceaux, en caractères. Trop petits, ils perdent le contexte ; trop grands, ils diluent l’information pertinente.
• chunk_overlap : le chevauchement entre deux morceaux, qui évite de couper une idée en plein milieu.
• Les métadonnées : PyPDFLoader conserve le nom du fichier et le numéro de page de chaque morceau, ce qui permettra de citer les sources.

Étape 5 — Construire la chaîne RAG

La chaîne relie quatre éléments : le retriever (qui cherche les morceaux pertinents), le prompt (qui encadre le modèle), le modèle et un parseur qui renvoie du texte. Créez rag_chain.py :

from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectordb = Chroma(persist_directory="chroma_db", embedding_function=embeddings)
retriever = vectordb.as_retriever(search_kwargs={"k": 4})

llm = ChatOllama(model="mistral", temperature=0.1)

prompt = ChatPromptTemplate.from_messages([
    ("system",
     "Tu es un assistant documentaire. Réponds en français, uniquement à partir "
     "du contexte ci-dessous. Si la réponse ne s'y trouve pas, réponds : "
     "« Je ne trouve pas cette information dans les documents. » "
     "Termine en citant les sources entre crochets.\n\nContexte :\n{context}"),
    ("human", "{question}"),
])

def format_docs(docs):
    return "\n\n".join(
        f"[{d.metadata.get('source')} p.{d.metadata.get('page')}] {d.page_content}"
        for d in docs
    )

chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

if __name__ == "__main__":
    while True:
        question = input("\nVotre question (ou 'quit') : ")
        if question.lower() in {"quit", "exit"}:
            break
        for morceau in chain.stream(question):
            print(morceau, end="", flush=True)

Lancez python rag_chain.py et posez une question dont la réponse se trouve dans vos PDF. La syntaxe avec le symbole | est le langage d’expression de LangChain (LCEL) : chaque étape reçoit la sortie de la précédente. Le paramètre k fixe le nombre de morceaux transmis au modèle.

Étape 6 — Déployer le chatbot dans une interface web

Pour que des utilisateurs non techniques puissent s’en servir, ajoutez une interface avec Streamlit. Créez app.py :

import streamlit as st
from rag_chain import chain

st.title("Assistant documentaire")

if "messages" not in st.session_state:
    st.session_state.messages = []

for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

if question := st.chat_input("Posez votre question sur les documents"):
    st.session_state.messages.append({"role": "user", "content": question})
    with st.chat_message("user"):
        st.markdown(question)
    with st.chat_message("assistant"):
        reponse = st.write_stream(chain.stream(question))
    st.session_state.messages.append({"role": "assistant", "content": reponse})

Lancez streamlit run app.py : l’application s’ouvre dans votre navigateur. Vous disposez d’un chatbot RAG complet, qui fonctionne sans connexion Internet une fois les modèles téléchargés.

Améliorer la qualité d’un chatbot RAG

Un premier prototype fonctionne vite. Le rendre fiable demande quelques réglages, à tester un par un avec une liste fixe de questions dont vous connaissez les réponses.

• Ajuster le découpage : pour des documents juridiques ou techniques structurés, des morceaux de 800 à 1 200 caractères donnent souvent un bon équilibre. Testez plusieurs valeurs sur vos documents.
• Régler le nombre d’extraits : augmenter k apporte plus de contexte, mais aussi plus de bruit et des réponses plus lentes.
• Filtrer par métadonnées : Chroma permet de restreindre la recherche à un document ou une catégorie, utile quand la base mélange plusieurs thèmes.
• Soigner le prompt système : l’instruction « réponds uniquement à partir du contexte » et la phrase de repli en cas d’absence d’information sont les deux garde-fous les plus efficaces contre les inventions.
• Nettoyer les documents : en-têtes et pieds de page répétés, tables des matières et pages blanches polluent la recherche. Retirez-les avant l’ingestion quand c’est possible.
• Réindexer proprement : quand un document change, supprimez la base et relancez ingest.py, ou gérez des identifiants de documents pour mettre à jour uniquement ce qui a changé.

Pour mesurer vos progrès, constituez un jeu de test de quinze à vingt questions réelles, avec pour chacune la réponse attendue et le document qui la contient. Après chaque modification (taille des morceaux, valeur de k, prompt, modèle), relancez ces questions et notez trois choses : le bon passage a-t-il été retrouvé ? La réponse est-elle exacte ? La source citée est-elle la bonne ? Cette discipline simple évite d’améliorer un cas en dégradant tous les autres, et vous permet de justifier vos choix techniques auprès de votre équipe.

Les erreurs fréquentes en RAG (et comment les éviter)

Erreur	Symptôme	Solution
Modèle d’embeddings différent entre ingestion et requête	Résultats incohérents ou vides	Utiliser exactement le même modèle dans ingest.py et rag_chain.py
PDF scannés	Aucun morceau indexé pour certains fichiers	Appliquer une reconnaissance de caractères (OCR) avant l’ingestion
Morceaux trop petits	Réponses incomplètes, sans contexte	Augmenter chunk_size et chunk_overlap
Prompt trop permissif	Le modèle complète avec ses propres connaissances	Exiger une réponse fondée sur le contexte et une phrase de repli
Oubli de l’environnement virtuel	ModuleNotFoundError au lancement	Activer .venv avant chaque session
Ollama arrêté	Erreur de connexion sur le port 11434	Lancer l’application Ollama ou ollama serve
Base jamais mise à jour	Réponses fondées sur des versions obsolètes	Relancer l’ingestion après chaque modification des documents

En formation, l’erreur la plus fréquente est de juger le modèle alors que le problème vient de la recherche. Avant de changer de modèle, affichez les morceaux renvoyés par le retriever : si la bonne information n’y figure pas, le meilleur modèle du monde ne pourra pas répondre.

Du chatbot RAG à l’agent IA

Un chatbot RAG répond à des questions. Un agent IA va plus loin : il décide lui-même des actions à mener et peut appeler des outils (recherche dans la base, calcul, requête à une API, écriture d’un fichier). Le RAG devient alors l’un des outils de l’agent, qui choisit de consulter la documentation seulement quand c’est utile.

LangChain permet de définir des outils sous forme de fonctions Python et de les confier à un modèle capable d’appels d’outils. Pour comprendre les principes de conception d’un agent (objectif, outils, mémoire, garde-fous), consultez notre guide pour créer un agent IA. Si vous souhaitez orchestrer plusieurs agents spécialisés qui collaborent, CrewAI est une alternative dédiée, et pour une approche sans code, les agents IA dans n8n reprennent les mêmes concepts dans une interface visuelle.

RAG local ou RAG avec une API en ligne : comparaison

Critère	RAG local (Ollama)	RAG avec API en ligne
Confidentialité	Totale, rien ne quitte la machine	Documents envoyés au fournisseur
Coût	Matériel uniquement	Facturation au token
Qualité des réponses	Bonne avec un modèle moyen bien guidé	Généralement supérieure sur les questions complexes
Vitesse	Dépend de votre GPU et de la RAM	Rapide et constante
Mise en production multi-utilisateurs	Nécessite un serveur adapté	Simple, l’infrastructure est gérée
Changement de modèle	Une commande ollama pull	Changement de fournisseur ou de clé

L’architecture LangChain reste la même dans les deux cas : vous pouvez prototyper en local, puis basculer une partie des traitements vers une API si les besoins de qualité ou de charge l’exigent.

Comment apprendre à créer des agents RAG avec LangChain ?

Voici le parcours que nous recommandons pour devenir autonome :

1. Les bases : Python, environnements virtuels, installation de dépendances, gestion sécurisée des clés.
2. Le modèle local : installer Ollama, tester Llama et Mistral, comprendre la température et le contexte.
3. LangChain : prompts, modèles, parseurs et chaînes LCEL, d’abord sans RAG.
4. Le RAG : ingestion, embeddings, base vectorielle, retriever, puis chaîne complète.
5. Le produit : interface Streamlit, jeux de questions de test, amélioration itérative, premier agent.

Pour être guidé pas à pas dans VS Code, la formation vidéo sur les agents IA avec Ollama, Mistral, RAG et LangChain d’EspritAcadémique couvre ce parcours en trois heures, fichiers ressources fournis. Au programme notamment :

• la configuration de l’espace de travail : vérification de Python, environnement virtuel, dépendances et clés API ;
• l’installation d’Ollama et les tests pratiques avec Llama ;
• la théorie de LangChain et son utilisation avec Ollama dans VS Code ;
• le concept de RAG, l’ingestion des données et la mécanique de la chaîne ;
• la création d’un premier agent et le travail avec Mistral en local ;
• la construction puis le déploiement d’un chatbot RAG complet.

En résumé

Un chatbot RAG LangChain local repose sur une idée simple : chercher d’abord, répondre ensuite. Ollama fournit le modèle de chat et le modèle d’embeddings, LangChain assemble chargeurs, découpeur, base vectorielle et chaîne, et Streamlit offre une interface en quelques lignes. La qualité se joue sur le découpage, le prompt et la vérification des extraits retrouvés, bien plus que sur la taille du modèle.