LangChain : Construis ton premier pipeline d'IA conversationnelle en 30 minutes

Tu sais interroger ChatGPT. Mais sais-tu construire un pipeline qui enchaîne plusieurs appels LLM, fouille tes propres documents, et se souvient de ce que tu as dit il y a 10 messages ? C'est exactement ce que LangChain permet de faire. Et dans ce tutoriel, on va le faire ensemble, de zéro.

Qu'est-ce que LangChain, et pourquoi tu devrais t'y intéresser ?

LangChain est un framework Python (et JavaScript) créé par Harrison Chase en 2022. Son idée est simple : un LLM seul, c'est un cerveau sans corps. Il peut réfléchir, mais il ne peut pas agir. LangChain lui donne des bras — accès à des APIs, des bases de données, des fichiers, d'autres LLMs, et même des outils comme Google Search ou une calculatrice.

Concrètement, LangChain permet de :

Chaîner plusieurs appels LLM (la sortie du premier devient l'entrée du second)
Connecter un LLM à tes propres documents (RAG — Retrieval Augmented Generation)
Ajouter de la mémoire pour qu'un chatbot se souvienne de votre conversation
Orchestrer des agents qui décident eux-mêmes quels outils utiliser

À la fin de ce tutoriel, tu auras construit un mini-assistant qui lit tes notes personnelles et répond à tes questions en s'appuyant dessus. Pas de cloud, pas d'abonnement : tout tourne sur ta machine.

Ce qu'il te faut

Python 3.10 ou plus récent
Un terminal ouvert
Une clé API OpenAI (ou un modèle local via Ollama — on verra les deux)

💡 Idée d'illustration : Un schéma en trois blocs — « Document → Vector Store → LLM → Réponse » — avec des flèches entre eux. Simple, clair, qui donne envie de comprendre.

Étape 1 : Installer LangChain

Ouvre ton terminal et crée un environnement propre :

bash

mkdir mon-assistant-langchain
cd mon-assistant-langchain
python3 -m venv venv
source venv/bin/activate
pip install langchain langchain-openai langchain-community chromadb python-dotenv

Ce qu'on installe :

Package	Rôle
`langchain`	Le framework principal
`langchain-openai`	L'intégration avec les modèles OpenAI
`langchain-community`	Utilitaires communautaires (loaders de documents, etc.)
`chromadb`	Base vectorielle légère pour notre RAG
`python-dotenv`	Pour gérer proprement la clé API dans un fichier `.env`

Crée un fichier .env à la racine :

bash

echo 'OPENAI_API_KEY=sk-ta-cle-ici' > .env

Remplace sk-ta-cle-ici par ta véritable clé OpenAI. Ce fichier ne sera jamais commité (ajoute .env dans ton .gitignore).

Étape 2 : Ton premier appel LLM avec LangChain

On commence par le plus simple : un appel à GPT-4o-mini via LangChain. Crée un fichier 01_basic.py :

python

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

# Initialise le modèle
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

# Appel simple
reponse = llm.invoke("Explique-moi ce qu'est une régression linéaire en une phrase.")
print(reponse.content)

Lance-le :

bash

python3 01_basic.py

Tu dois voir une réponse concise et pédagogique. Ce que tu viens de faire : 1. ChatOpenAI crée un objet qui encapsule le modèle 2. .invoke() envoie ton message et récupère la réponse 3. .content extrait le texte du message

Jusqu'ici, rien de magique — tu aurais pu faire la même chose avec openai.ChatCompletion. La force de LangChain apparaît quand on commence à chaîner.

Étape 3 : Créer ta première chaîne (LCEL)

LangChain Express Language (LCEL) est la syntaxe moderne pour composer des pipelines avec l'opérateur | (pipe), comme dans un terminal Unix. Crée 02_chain.py :

python

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

load_dotenv()

# 1. Le template de prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un professeur de {matiere}. Explique de façon claire et concise."),
    ("user", "Explique-moi : {question}")
])

# 2. Le modèle
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

# 3. Le parser (transforme la réponse en string simple)
parser = StrOutputParser()

# 4. La chaîne !
chaine = prompt | llm | parser

# 5. On l'utilise
resultat = chaine.invoke({
    "matiere": "physique quantique",
    "question": "le principe d'incertitude de Heisenberg"
})

print(resultat)

bash

python3 02_chain.py

La ligne magique, c'est prompt | llm | parser. Chaque étape passe sa sortie à l'étape suivante : - prompt formate le texte avec matiere et question - llm génère la réponse - parser extrait le texte brut

C'est comme un pipeline Unix : cat data | grep important | sort. Simple, lisible, et incroyablement puissant quand on commence à empiler.

Ce que tu dois voir : Une explication claire du principe d'incertitude, rédigée comme un prof de physique quantique, en français.

Étape 4 : Ajouter de la mémoire conversationnelle

Un LLM sans mémoire, c'est comme parler à quelqu'un qui a Alzheimer. Chaque message est traité indépendamment. LangChain propose plusieurs types de mémoire. Crée 03_memoire.py :

python

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

load_dotenv()

# Prompt avec emplacement pour l'historique
prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant utile et concis."),
    MessagesPlaceholder(variable_name="historique"),
    ("user", "{question}")
])

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
parser = StrOutputParser()

chaine = prompt | llm | parser

# Stockage de l'historique en mémoire
store = {}

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

# Chaîne avec mémoire
chaine_avec_memoire = RunnableWithMessageHistory(
    chaine,
    get_session_history,
    input_messages_key="question",
    history_messages_key="historique",
)

# Simulation d'une conversation
config = {"configurable": {"session_id": "user-123"}}

print("🤖 Assistant : Salut ! Pose-moi des questions (tape 'quit' pour sortir)\n")

while True:
    user_input = input("👤 Toi : ")
    if user_input.lower() == "quit":
        break

    reponse = chaine_avec_memoire.invoke(
        {"question": user_input},
        config=config
    )
    print(f"🤖 Assistant : {reponse}\n")

bash

python3 03_memoire.py

Pose trois questions qui s'enchaînent logiquement, par exemple : 1. « Je m'appelle Thomas. » 2. « Quel est mon prénom ? » 3. « Donne-moi un conseil de productivité personnalisé. »

L'assistant doit se souvenir de ton prénom à l'étape 2 et l'utiliser à l'étape 3. C'est le RunnableWithMessageHistory qui fait le travail : il injecte automatiquement l'historique de la conversation dans le prompt.

Étape 5 : Construire un mini-RAG (on passe HÉRO)

C'est le cœur du tutoriel. On va construire un assistant qui lit un document, le découpe en morceaux, les vectorise, et répond à tes questions en cherchant les passages pertinents. Le tout en local avec ChromaDB.

Crée 04_rag.py :

python

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

load_dotenv()

# === 1. Crée un document de test ===
contenu = """# Notes de Recherche IA - Juillet 2026

## Transformers
L'architecture Transformer, introduite par Vaswani et al. en 2017, repose
sur le mécanisme d'attention. Ce mécanisme permet au modèle de pondérer
l'importance de chaque mot par rapport aux autres dans une phrase.

## Fine-tuning
Le fine-tuning consiste à prendre un modèle pré-entraîné et à l'adapter
à une tâche spécifique avec peu de données. Par exemple, on peut fine-tuner
GPT sur des emails pour créer un assistant de rédaction.

## RAG
Le Retrieval Augmented Generation combine un moteur de recherche et un LLM.
Le LLM reçoit les documents pertinents en contexte plutôt que de tout mémoriser.
Cela réduit les hallucinations et permet de référencer les sources.

## Modèles Open-Source
Llama 4 (Meta) et Mistral Large 3 sont les leaders open-source en juillet 2026.
Ils atteignent des performances proches de GPT-4o sur la plupart des benchmarks.
"""

with open("notes_recherche.txt", "w") as f:
    f.write(contenu)

# === 2. Charge et découpe le document ===
loader = TextLoader("notes_recherche.txt", encoding="utf-8")
documents = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=300,       # Taille de chaque morceau en caractères
    chunk_overlap=50,     # Chevauchement entre morceaux (évite de couper en plein milieu)
    separators=["\n\n", "\n", " ", ""]
)
chunks = splitter.split_documents(documents)

print(f"📄 Document découpé en {len(chunks)} morceaux.\n")

# === 3. Vectorise et stocke dans ChromaDB ===
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_notes"
)

# === 4. Crée le retriever ===
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# === 5. Construis la chaîne RAG ===
template = """Tu es un assistant de recherche qui répond UNIQUEMENT à partir
des documents fournis ci-dessous. Si la réponse n'est pas dans les documents,
dis-le honnêtement.

Documents :
{contexte}

Question : {question}

Réponse :"""

prompt = ChatPromptTemplate.from_template(template)
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)
parser = StrOutputParser()

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

chaine_rag = (
    {"contexte": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | parser
)

# === 6. Pose des questions ! ===
questions = [
    "C'est quoi un Transformer ?",
    "Comment fonctionne le RAG ?",
    "Quels sont les meilleurs modèles open-source en juillet 2026 ?",
    "Quelle est la capitale de l'Australie ?",  # Pas dans le doc
]

for q in questions:
    reponse = chaine_rag.invoke(q)
    print(f"❓ {q}")
    print(f"💡 {reponse}\n")
    print("-" * 60 + "\n")

bash

python3 04_rag.py

Ce que tu dois observer :

Pour « C'est quoi un Transformer ? » : réponse extraite de tes notes
Pour « Quelle est la capitale de l'Australie ? » : le modèle répond honnêtement qu'il ne sait pas (car ce n'est pas dans tes documents)

Tu viens de construire un système RAG complet en moins de 80 lignes de Python ! Voici ce qui se passe sous le capot :

Ton document est découpé en chunks de ~300 caractères avec chevauchement
Chaque chunk est converti en vecteur (embedding) via OpenAI text-embedding-3-small
Ces vecteurs sont stockés dans ChromaDB
Quand tu poses une question, elle est aussi vectorisée
ChromaDB trouve les 2 chunks les plus similaires (recherche par similarité cosinus)
Ces chunks sont injectés dans le prompt avec ta question
Le LLM répond en s'appuyant exclusivement sur ces documents

Étape 6 : Passer en local avec Ollama (optionnel)

Si tu ne veux pas dépendre d'OpenAI, voici la version locale. Installe Ollama :

bash

# Linux / WSL
curl -fsSL https://ollama.com/install.sh | sh

# macOS : télécharge depuis https://ollama.com

# Lance le serveur et télécharge un modèle
ollama serve &
ollama pull llama3.2

Puis installe l'intégration LangChain pour Ollama :

bash

pip install langchain-ollama

Et modifie les imports :

python

from langchain_ollama import OllamaEmbeddings, ChatOllama

# Remplace OpenAI par Ollama
llm = ChatOllama(model="llama3.2", temperature=0.3)
embeddings = OllamaEmbeddings(model="nomic-embed-text")

bash

ollama pull nomic-embed-text   # Modèle d'embedding léger
python3 04_rag_local.py        # Ton script adapté

Le reste du code ne change pas. Tu fais tourner ton RAG en 100% local, sans connexion internet après le téléchargement initial des modèles.

Pièges classiques (et comment les éviter)

🪤 Erreur n°1 : Oublier le `.content`

python

reponse = llm.invoke("Bonjour")
print(reponse)  # Affiche un objet AIMessage, pas le texte !

✅ Corrige : print(reponse.content)

🪤 Erreur n°2 : Mélanger l'ancienne et la nouvelle API

LangChain a deux API : l'ancienne (LLMChain) et la nouvelle (LCEL avec |). Ne les mélange pas. Utilise uniquement LCEL pour tout nouveau projet. L'ancienne API est dépréciée.

🪤 Erreur n°3 : Chunks trop grands ou trop petits

Chunks < 100 caractères : pas assez de contexte, le LLM ne comprend rien
Chunks > 1000 caractères : la recherche vectorielle perd en précision
✅ Sweet spot : 300-500 caractères avec 50-100 de chevauchement

🪤 Erreur n°4 : Mauvaise config ChromaDB

Si tu vois InvalidDimensionException, c'est que ton modèle d'embedding a changé entre deux exécutions. Supprime le dossier ./chroma_notes et relance.

🪤 Erreur n°5 : API key non trouvée

python

openai.OpenAIError: The api_key client option must be set

✅ Vérifie que ton fichier .env est bien à la racine du projet ET que load_dotenv() est appelé avant toute création de modèle.

Pour aller plus loin

Ajoute plusieurs sources : Remplace TextLoader par DirectoryLoader pour indexer tout un dossier de .txt, .pdf (avec PyPDFLoader), ou même des pages web (avec WebBaseLoader).

Passe à un vrai vector store : ChromaDB est parfait pour démarrer, mais pour la production, explore pgvector (PostgreSQL) ou Pinecone (cloud). Le code LangChain change très peu — c'est la beauté du framework.

Crée un agent autonome : Avec langchain.agents, ton LLM peut décider lui-même d'aller chercher dans les documents, d'utiliser une calculatrice, ou d'appeler une API météo. C'est le sujet du tutoriel CrewAI qu'on a déjà couvert — la suite logique !

Récapitulatif

Ce que tu as appris	Fichier
Appel LLM simple	`01_basic.py`
Chaîne avec template + pipe	`02_chain.py`
Mémoire conversationnelle	`03_memoire.py`
RAG complet (document → réponse)	`04_rag.py`

Tu es parti de zéro — tu n'avais jamais touché LangChain. Tu finis avec un moteur de recherche sémantique sur tes propres documents, capable de répondre à des questions en contexte. C'est exactement la techno qui alimente les chatbots d'entreprise, les assistants de documentation, et les moteurs de recherche internes.

Ton prochain défi : Prends 04_rag.py, remplace notes_recherche.txt par ton vrai carnet de notes ou ta documentation de projet, et vois la magie opérer. Tu viens de passer de « j'utilise ChatGPT » à « je construis des pipelines d'IA » — niveau HÉRO débloqué. 🦸

Qu'est-ce que LangChain, et pourquoi tu devrais t'y intéresser ?

Ce qu'il te faut

Étape 1 : Installer LangChain

Étape 2 : Ton premier appel LLM avec LangChain

Étape 3 : Créer ta première chaîne (LCEL)

Étape 4 : Ajouter de la mémoire conversationnelle

Étape 5 : Construire un mini-RAG (on passe HÉRO)

Étape 6 : Passer en local avec Ollama (optionnel)

Pièges classiques (et comment les éviter)

🪤 Erreur n°1 : Oublier le .content

🪤 Erreur n°2 : Mélanger l'ancienne et la nouvelle API

🪤 Erreur n°3 : Chunks trop grands ou trop petits

🪤 Erreur n°4 : Mauvaise config ChromaDB

🪤 Erreur n°5 : API key non trouvée

Pour aller plus loin

Récapitulatif

🪤 Erreur n°1 : Oublier le `.content`