Chatbot Entreprise avec RAG et LangChain : Guide Pas à Pas

from langchain_community.document_loaders import (
    PyMuPDFLoader,
    Docx2txtLoader,
    ConfluenceLoader,
    NotionDBLoader,
    DirectoryLoader
)
from langchain.schema import Document
from pathlib import Path
import logging

logger = logging.getLogger(__name__)

class EnterpriseDocumentLoader:
    """Pipeline d'ingestion multi-sources pour chatbot entreprise."""

    def __init__(self, config: dict):
        self.config = config
        self.documents: list[Document] = []

    def load_pdfs(self, directory: str) -> list[Document]:
        """Charge tous les PDF d'un répertoire."""
        loader = DirectoryLoader(
            directory,
            glob="**/*.pdf",
            loader_cls=PyMuPDFLoader,
            show_progress=True,
            use_multithreading=True
        )
        docs = loader.load()
        logger.info(f"Chargé {len(docs)} pages PDF depuis {directory}")
        return self._enrich_metadata(docs, source_type="pdf")

    def load_confluence(self, space_key: str) -> list[Document]:
        """Charge les pages Confluence d'un espace."""
        loader = ConfluenceLoader(
            url=self.config["confluence_url"],
            username=self.config["confluence_user"],
            api_key=self.config["confluence_token"],
            space_key=space_key,
            include_attachments=True,
            limit=100
        )
        docs = loader.load()
        logger.info(f"Chargé {len(docs)} pages Confluence ({space_key})")
        return self._enrich_metadata(docs, source_type="confluence")

    def _enrich_metadata(self, docs, source_type: str):
        """Enrichit les métadonnées pour le filtrage et la traçabilité."""
        for doc in docs:
            doc.metadata["source_type"] = source_type
            doc.metadata["ingested_at"] = datetime.now().isoformat()
            doc.metadata["company"] = self.config.get("company_name", "default")
        return docs

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_experimental.text_splitter import SemanticChunker
from langchain_openai import OpenAIEmbeddings

# Stratégie 1 : RecursiveCharacter (recommandé pour commencer)
recursive_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,          # Taille cible en caractères
    chunk_overlap=200,        # Chevauchement pour le contexte
    length_function=len,
    separators=["\n\n", "\n", ". ", " ", ""],
    is_separator_regex=False
)
chunks = recursive_splitter.split_documents(documents)

# Stratégie 2 : SemanticChunker (pour du contenu varié)
semantic_splitter = SemanticChunker(
    embeddings=OpenAIEmbeddings(model="text-embedding-3-small"),
    breakpoint_threshold_type="percentile",
    breakpoint_threshold_amount=95  # Seuil de similarité pour couper
)
semantic_chunks = semantic_splitter.split_documents(documents)

print(f"Recursive: {len(chunks)} chunks | Semantic: {len(semantic_chunks)} chunks")

Voici l'intégration complète embeddings + vector store avec LangChain :

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma, Qdrant, Milvus
from langchain.schema import Document

# Initialisation du modèle d'embeddings
embeddings = OpenAIEmbeddings(
    model="text-embedding-3-large",
    dimensions=1024  # Dimension shortening pour économiser
)

# Option 1 : ChromaDB (développement / prototypage)
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db",
    collection_name="chatbot_rh"
)

# Option 2 : Qdrant (production)
from qdrant_client import QdrantClient
vectorstore = Qdrant.from_documents(
    documents=chunks,
    embedding=embeddings,
    url="http://localhost:6333",
    collection_name="chatbot_rh",
    force_recreate=False
)

# Retriever avec paramètres optimisés
retriever = vectorstore.as_retriever(
    search_type="similarity",      # ou "mmr" pour diversifier
    search_kwargs={
        "k": 5,                       # Nombre de chunks à récupérer
        "score_threshold": 0.7       # Seuil de pertinence minimum
    }
)

5 Construction avec LangChain

LangChain 0.3+ introduit le LCEL (LangChain Expression Language) qui remplace l'ancienne API des Chains. Le LCEL offre une syntaxe déclarative avec le pipe operator (|) pour composer des pipelines RAG de manière élégante et maintenable.

Prompt Template RAG

Le prompt template est le coeur de votre chatbot RAG. Il doit instruire le LLM à répondre uniquement à partir du contexte fourni, en citant ses sources, et en avouant son ignorance quand l'information n'est pas disponible :

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

RAG_PROMPT = ChatPromptTemplate.from_messages([
    ("system", """Tu es un assistant d'entreprise spécialisé et précis.
Tu réponds UNIQUEMENT à partir du contexte fourni ci-dessous.
Si l'information n'est pas dans le contexte, dis-le clairement.
Cite toujours la source de tes informations entre crochets [source].
Réponds en français de manière professionnelle et concise.

Contexte:
{context}

Règles:
- Ne fabrique JAMAIS d'information
- Si plusieurs sources se contredisent, mentionne-le
- Propose de contacter le service concerné si la question dépasse le contexte"""),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{question}")
])

Chaîne RAG Complète avec LCEL

Voici l'implémentation complète d'un chatbot RAG conversationnel avec mémoire, utilisant le LCEL de LangChain 0.3+ :

Mise en oeuvre et bonnes pratiques

from langchain_openai import ChatOpenAI
from langchain_core.runnables import RunnablePassthrough, RunnableParallel
from langchain_core.output_parsers import StrOutputParser
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# Initialisation du LLM
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.1,        # Bas pour des réponses factuelles
    max_tokens=1500,
    streaming=True          # Pour la réponse en streaming
)

# Fonction de formatage du contexte
def format_docs(docs):
    formatted = []
    for i, doc in enumerate(docs, 1):
        source = doc.metadata.get('source', 'Inconnu')
        page = doc.metadata.get('page', '')
        ref = f"{source}" + (f" p.{page}" if page else "")
        formatted.append(f"[Source {i}: {ref}]\n{doc.page_content}")
    return "\n\n---\n\n".join(formatted)

# Chaîne RAG avec LCEL
rag_chain = (
    RunnableParallel(
        context=retriever | format_docs,
        question=RunnablePassthrough(),
        chat_history=lambda x: x.get("chat_history", [])
    )
    | RAG_PROMPT
    | llm
    | StrOutputParser()
)

# Ajout de la mémoire conversationnelle
message_histories = {}

def get_session_history(session_id: str):
    if session_id not in message_histories:
        message_histories[session_id] = ChatMessageHistory()
    return message_histories[session_id]

chatbot = RunnableWithMessageHistory(
    rag_chain,
    get_session_history,
    input_messages_key="question",
    history_messages_key="chat_history"
)

# Utilisation
response = chatbot.invoke(
    {"question": "Combien de jours de congés ai-je droit ?"},
    config={"configurable": {"session_id": "user_001"}}
)
print(response)

Gestion de la Mémoire Conversationnelle

La mémoire est essentielle pour un chatbot d'entreprise : elle permet les questions de suivi ("Et pour les RTT ?"), les clarifications, et maintient le contexte de la conversation. LangChain propose plusieurs stratégies :

• ▹ChatMessageHistory — Stocke l'intégralité des messages. Simple mais peut dépasser la fenêtre de contexte du LLM pour les longues conversations.
• ▹ConversationBufferWindowMemory — Conserve les k derniers échanges. Bon compromis pour la plupart des cas d'usage (k=5 à 10 recommandé).
• ▹ConversationSummaryMemory — Résume les échanges précédents via le LLM. Utile pour les conversations très longues (support technique multi-étapes).
• ▹ConversationTokenBufferMemory — Garde autant de messages que possible dans une limite de tokens. Le plus prévisible en termes de coûts.

6 Optimisation et Qualité

Un chatbot RAG fonctionnel n'est que le début. Pour atteindre un niveau de qualité production, il faut optimiser le retrieval, implémenter le reranking, et mettre en place une évaluation continue. Cette section couvre les techniques avancées qui font la différence entre un prototype et un outil métier fiable.

Reranking : la clé de la pertinence

La recherche vectorielle initiale (bi-encoder) est rapide mais approximative. Le reranking utilise un cross-encoder plus puissant pour ré-ordonner les résultats et éliminer les faux positifs. C'est l'optimisation avec le meilleur retour sur investissement : Pour approfondir, consultez OWASP Top 10 pour les LLM : Guide Remédiation 2026.

from langchain.retrievers import ContextualCompressionRetriever
from langchain_cohere import CohereRerank
from langchain.retrievers.document_compressors import CrossEncoderReranker
from langchain_community.cross_encoders import HuggingFaceCrossEncoder

# Option 1 : Cohere Rerank (cloud, très performant)
cohere_reranker = CohereRerank(
    model="rerank-v3.5",
    top_n=3   # Garder les 3 meilleurs après reranking
)

# Option 2 : Cross-encoder local (self-hosted, gratuit)
cross_encoder = HuggingFaceCrossEncoder(
    model_name="cross-encoder/ms-marco-MiniLM-L-12-v2"
)
local_reranker = CrossEncoderReranker(
    model=cross_encoder, top_n=3
)

# Retriever avec reranking intégré
compression_retriever = ContextualCompressionRetriever(
    base_compressor=cohere_reranker,
    base_retriever=vectorstore.as_retriever(search_kwargs={"k": 20})
    # Récupère 20 docs, rerank garde les 3 meilleurs
)

Hybrid Search : le meilleur des deux mondes

La recherche hybride combine la recherche sémantique (dense vectors) avec la recherche lexicale (BM25/sparse). Cela couvre les cas où la recherche sémantique seule échoue, notamment pour les termes techniques spécifiques, les numéros de référence, ou les acronymes métier :

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever

# Retriever dense (sémantique)
dense_retriever = vectorstore.as_retriever(search_kwargs={"k": 10})

# Retriever sparse (BM25 lexical)
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 10

# Ensemble : fusion avec pondération
hybrid_retriever = EnsembleRetriever(
    retrievers=[dense_retriever, bm25_retriever],
    weights=[0.6, 0.4]  # 60% sémantique, 40% lexical
)

Évaluation avec RAGAS

L'évaluation d'un chatbot RAG nécessite des métriques spécifiques. Le framework RAGAS (Retrieval Augmented Generation Assessment) est devenu le standard en 2026 pour mesurer la qualité d'un pipeline RAG :

• ▹Faithfulness — La réponse est-elle fidèle au contexte fourni ? Mesure les hallucinations. Score cible : >0.85.
• ▹Answer Relevancy — La réponse répond-elle bien à la question posée ? Détecte les réponses hors sujet. Score cible : >0.80.
• ▹Context Precision — Les chunks récupérés sont-ils pertinents pour la question ? Mesure la qualité du retrieval. Score cible : >0.75.
• ▹Context Recall — Le retrieval a-t-il trouvé tous les chunks nécessaires pour répondre ? Détecte les informations manquantes. Score cible : >0.70.

from ragas import evaluate
from ragas.metrics import (
    faithfulness, answer_relevancy,
    context_precision, context_recall
)
from datasets import Dataset

# Préparer le jeu de test
eval_data = {
    "question": [
        "Combien de jours de congés annuels ?",
        "Quelle est la procédure de télétravail ?",
        "Comment déclarer un accident de travail ?"
    ],
    "answer": [resp1, resp2, resp3],  # Réponses du chatbot
    "contexts": [ctx1, ctx2, ctx3],   # Chunks récupérés
    "ground_truth": [gt1, gt2, gt3]   # Réponses de référence
}

result = evaluate(
    Dataset.from_dict(eval_data),
    metrics=[faithfulness, answer_relevancy,
             context_precision, context_recall]
)
print(result)  # {'faithfulness': 0.92, 'answer_relevancy': 0.87, ...}

7 Déploiement et Production

Le passage en production d'un chatbot RAG d'entreprise exige une attention particulière à la performance, la sécurité, le monitoring et la gestion des coûts. Voici un guide complet pour déployer et opérer votre chatbot de manière fiable et pérenne.

API avec FastAPI et LangServe

LangServe transforme votre chaîne LangChain en API REST production-ready avec documentation OpenAPI automatique, support du streaming, et playground intégré :

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from langserve import add_routes
from pydantic import BaseModel
import uvicorn

app = FastAPI(
    title="Chatbot RH - API RAG",
    version="1.0.0",
    description="API chatbot d'entreprise avec RAG et LangChain"
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://intranet.entreprise.fr"],
    allow_methods=["POST"],
    allow_headers=["*"],
)

# Expose la chaîne RAG via LangServe
add_routes(
    app,
    chatbot,  # La chaîne RunnableWithMessageHistory
    path="/chat",
    enable_feedback_endpoint=True,
    enable_public_trace_link_endpoint=False
)

# Endpoint de santé
@app.get("/health")
async def health_check():
    return {"status": "healthy", "vector_count": vectorstore._collection.count()}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Monitoring et Observabilité

En production, vous devez surveiller chaque étape du pipeline RAG pour détecter les dégradations et optimiser en continu. Les outils de monitoring essentiels :

• ▹LangSmith — Plateforme officielle LangChain pour le tracing, l'évaluation et le monitoring. Visualise chaque étape de la chaîne avec latences et tokens consommés. Indispensable en production.
• ▹Prometheus + Grafana — Métriques techniques : latence P50/P95/P99, throughput, taux d'erreur, utilisation mémoire du vector store.
• ▹Métriques métier — Taux de satisfaction utilisateur (thumbs up/down), taux de fallback vers un humain, questions sans réponse, nombre de tours de conversation moyen.

Sécurité et Conformité

La sécurité d'un chatbot d'entreprise est primordiale, surtout lorsqu'il accède à des données sensibles (RH, juridique, financier). Mesures essentielles à implémenter :

Analyse approfondie et recommandations

• ▹Contrôle d'accès (RBAC) — Filtrez les documents accessibles selon le rôle de l'utilisateur. Utilisez les métadonnées du vector store pour le filtrage : filter={"department": user.department}.
• ▹Prompt injection protection — Validez et nettoyez les entrées utilisateur. Utilisez un LLM garde-fou (guardrails) pour détecter les tentatives de jailbreak et les requêtes malveillantes.
• ▹Audit trail — Loguez chaque interaction (question, contexte récupéré, réponse générée) pour la traçabilité RGPD et les audits de conformité.
• ▹Chiffrement — TLS en transit, chiffrement at-rest pour le vector store. Les embeddings peuvent être inversés partiellement : traitez-les comme des données sensibles.

Gestion des Coûts

Les coûts d'un chatbot RAG se répartissent entre embeddings, LLM, infrastructure et monitoring. Voici une estimation typique pour un chatbot RH servant 500 utilisateurs/jour :

• ▹Embeddings (ingestion) — ~$5/mois pour 10K documents (one-time + mises à jour). Coût marginal avec text-embedding-3-small.
• ▹LLM (génération) — ~$150-400/mois avec GPT-4o (500 requêtes/jour, ~1500 tokens/requête). Réduisible avec GPT-4o-mini ou Mistral pour les questions simples.
• ▹Vector Store — Qdrant Cloud ~$25/mois pour 1M vecteurs. Self-hosted : coût serveur uniquement (~$50/mois VM dédiée).
• ▹Reranking — Cohere Rerank ~$1/1000 requêtes. ~$15/mois pour 500 requêtes/jour.

Maintenance de la Base Documentaire

Un chatbot RAG n'est utile que si sa base documentaire est à jour. Mettez en place un pipeline de mise à jour continue : Pour approfondir, consultez Red Teaming IA 2026 : Tester les LLM en Entreprise.

• ▹Incremental indexing — Utilisez les métadonnées (hash du contenu, date de modification) pour ne réindexer que les documents modifiés. LangChain fournit le RecordManager pour gérer l'indexation incrémentale.
• ▹Webhooks — Connectez Confluence/Notion/SharePoint via webhooks pour déclencher la réindexation automatiquement lors de la mise à jour d'un document.
• ▹Expiration et archivage — Définissez une politique d'expiration pour les documents obsolètes (TTL sur les métadonnées). Un document RH de 2019 ne doit pas polluer les réponses sur la politique actuelle.
• ▹Feedback loop — Analysez les questions sans réponse et les feedbacks négatifs pour identifier les lacunes documentaires. Intégrez ce retour dans votre processus de rédaction documentaire.

À Propos de l'Auteur

Ayi NEDJIMI • Expert Cybersécurité & IA

Ayi NEDJIMI est un expert senior en cybersécurité offensive et intelligence artificielle avec plus de 20 ans d'expérience en développement avancé, tests d'intrusion et architecture de systèmes critiques. Spécialisé en rétro-ingénierie logicielle, forensics numériques et développement de modèles IA, il accompagne les organisations stratégiques dans la sécurisation d'infrastructures hautement sensibles.

Expert reconnu en expertises judiciaires et investigations forensiques, Ayi intervient régulièrement en tant que consultant expert auprès des plus grandes organisations françaises et européennes. Son expertise technique couvre l'audit Active Directory, le pentest cloud (AWS, Azure, GCP), la rétro-ingénierie de malwares, ainsi que l'implémentation de solutions RAG et bases vectorielles (Milvus, Qdrant, Weaviate) pour des applications IA d'entreprise.

20+Ans d'expérience

100+Missions réalisées

150+Articles & conférences

Conférencier et formateur reconnu en cybersécurité, Ayi anime régulièrement des conférences techniques et participe activement au développement de modèles d'intelligence artificielle pour la détection de menaces avancées. Auteur de plus de 150 publications techniques, il partage son expertise de haut niveau pour aider les RSSI et architectes sécurité à anticiper les cybermenaces émergentes et déployer des solutions IA de nouvelle génération.

📚 Tous ses articles 🛡️ Demander un audit 💼 LinkedIn

Pour approfondir ce sujet, consultez notre outil open-source ai-prompt-injection-detector qui facilite la détection des injections de prompt.

Questions frequentes

Pourquoi la securite des modeles LLM est-elle importante ?

La securite des modeles LLM est cruciale car ces systemes peuvent etre vulnerables aux injections de prompts, aux attaques par empoisonnement de donnees et aux fuites d'informations sensibles. Une securisation inadequate peut exposer l'organisation a des risques de confidentialite, d'integrite et de disponibilite.

Nous avons constitué un dataset spécialisé cybersec-qa-dataset-fr pour entraîner des modèles de question-réponse en cybersécurité.

Conclusion

Cet article a couvert les aspects essentiels de Table des Matières, 1 Introduction : Le Chatbot d'Entreprise Nouvelle Génération, 2 Architecture RAG pour Chatbot. La mise en pratique de ces recommandations permet de renforcer significativement la posture de securite de votre organisation.

Besoin d'un accompagnement expert ?

Ayi NEDJIMI, consultant en cybersecurite et intelligence artificielle, peut vous accompagner sur ce sujet : audit, formation ou conseil personnalise.

Demander un devis gratuit

Partager cet article

Twitter LinkedIn Copier le lien

Ayi NEDJIMI

Expert Cybersécurité & Intelligence Artificielle

Consultant et formateur spécialisé en tests d'intrusion, Active Directory, et développement de solutions IA. 15+ années d'expérience en sécurité offensive.

Articles connexes

Benchmark LLM Mars 2026 : Etat des Lieux Complet en 2026

Etat des lieux complet des benchmarks LLM en mars 2026 : classements, methodologies et limites des evaluations.

02/03/2026

Claude Opus 4.6 : Applications en Cybersecurite en 2026

Exploration des capacites de Claude Opus 4.6 pour les cas d'usage cybersecurite : analyse de code, threat hunting, audit.

01/03/2026

IA et Zero Trust : Micro-Segmentation Dynamique Pilotée par

Micro-segmentation réseau adaptative en temps réel pilotée par ML, scoring de confiance dynamique, UEBA et continuous authentication dans une architecture.

28/02/2026

Article précédent

IA et Automatisation RH : Screening CV et Compliance

Article suivant

Llama 4, Mistral Large, Gemma 3 : Comparatif LLM Open Source

Commentaires (1)

M

Marie David 26/01/2026 à 08:13

Article qui fait écho à notre vécu. Dans mon rôle de chef de projet sécurité, nous avons déployé un pipeline RAG pour notre base documentaire interne. Notre maturité sur ce sujet a nettement progressé. Merci pour ce partage qui confirme notre direction.

Laisser un commentaire

Nom *

Email * (non publié)

Commentaire *

Publier