LangChain : Tutoriel complet pour débutants 2026

Qu'est-ce que LangChain ?

LangChain est un framework Python (et JavaScript) qui simplifie la création d'applications utilisant des LLMs (Large Language Models). Il fournit des abstractions pour :

• Chaîner des appels LLM avec de la logique
• Connecter les LLMs à vos données (RAG)
• Créer des agents qui utilisent des outils
• Gérer la mémoire conversationnelle

Installation

pip install langchain langchain-openai langchain-community
pip install chromadb  # Pour le vector store

Concepts fondamentaux

1. Chat Models

L'interface pour communiquer avec les LLMs :

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4", temperature=0)
response = llm.invoke("Explique-moi les design patterns en une phrase")
print(response.content)

2. Prompt Templates

Pour structurer vos prompts de manière réutilisable :

from langchain.prompts import ChatPromptTemplate

template = ChatPromptTemplate.from_messages([
    ("system", "Tu es un expert en {domaine}. Réponds de manière concise."),
    ("human", "{question}")
])

prompt = template.format_messages(
    domaine="Python",
    question="C'est quoi un décorateur ?"
)
response = llm.invoke(prompt)

3. Chains (LCEL)

LangChain Expression Language permet de chaîner les composants :

from langchain_core.output_parsers import StrOutputParser

# Créer une chaîne
chain = template | llm | StrOutputParser()

# Exécuter
result = chain.invoke({
    "domaine": "DevOps",
    "question": "C'est quoi Kubernetes ?"
})
print(result)

RAG (Retrieval-Augmented Generation)

L'architecture RAG permet au LLM de répondre avec vos données :

Étape 1 : Charger les documents

from langchain_community.document_loaders import TextLoader, PyPDFLoader

# Charger un fichier texte
loader = TextLoader("documentation.txt")
documents = loader.load()

# Ou un PDF
loader = PyPDFLoader("manuel.pdf")
documents = loader.load()

Étape 2 : Découper en chunks

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = splitter.split_documents(documents)

Étape 3 : Créer le vector store

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

Étape 4 : Créer la chaîne RAG

from langchain.chains import RetrievalQA

retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

result = qa_chain.invoke({"query": "Comment configurer le module X ?"})
print(result["result"])

Agents

Les agents peuvent utiliser des outils pour accomplir des tâches :

from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import Tool
from langchain import hub

# Définir un outil
def recherche_web(query: str) -> str:
    # Votre logique de recherche
    return f"Résultats pour: {query}"

tools = [
    Tool(
        name="recherche",
        func=recherche_web,
        description="Recherche des informations sur le web"
    )
]

# Créer l'agent
prompt = hub.pull("hwchase17/openai-tools-agent")
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "Trouve les dernières news sur Python 3.13"})

Mémoire conversationnelle

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

conversation.predict(input="Je m'appelle Davy")
conversation.predict(input="Quel est mon prénom ?")  # Se souvient !

Bonnes pratiques

• Température : 0 pour les tâches précises, 0.7+ pour la créativité
• Chunk size : 500-1500 caractères généralement optimal pour RAG
• Chunk overlap : 10-20% du chunk_size
• Streaming : Utilisez stream() pour une meilleure UX
• Fallback : Prévoyez des réponses par défaut si le retrieval échoue

Conclusion

LangChain simplifie énormément le développement d'applications IA. Commencez par les chaînes simples, puis explorez RAG et les agents selon vos besoins.

Besoin d'aide pour développer une application LangChain ? Contactez-moi.

Davy Abderrahman

Expert IA et LangChain. Créateur de plusieurs applications RAG en production.

En savoir plus