Créer un RAG en Python avec LangChain v1 (agentique)

La génération augmentée par recherche (Retrieval-Augmented Generation ou RAG) combine les grands modèles de langage (LLM) avec des systèmes de recherche d’informations pour créer des applications d’IA plus fiables.

Cette approche aide à résoudre les limitations courantes des LLM comme les hallucinations et les connaissances obsolètes en ancrant les réponses dans des informations factuelles pertinentes.

Dans cet article, nous explorerons pas à pas le processus de construction d’un RAG en utilisant LangChain.

Mise à jour pour la v1.0 de LangChain (octobre 2025) : on vous explique comment écrire un RAG avec la toute nouvelle syntaxe “create_agent” !

Étape 1 : Comprendre l’intérêt d’un RAG

Les systèmes RAG améliorent les capacités des LLM en leur fournissant un contexte pertinent avant de générer des réponses.

Cette approche offre plusieurs avantages clés :

Accès aux données les plus récentes
Réduction des hallucinations grâce à l’ancrage
Adaptabilité à des domaines spécifiques sans réentraîner le modèle (alternative au fine-tuning)

Par exemple, les LLM ne connaissent pas encore la syntaxe de la v1 de LangChain, qui vient de sortir : un RAG est alors nécessaire pour générer du code valide et à jour avec les dernières avancées du framework.

Contrairement à un appel direct à un LLM, le RAG permet aux modèles de travailler avec vos données spécifiques et connaissances métier. Cela les rend plus précis pour des applications spécialisées où la fiabilité est importante.

C’est pourquoi créer un RAG est au coeur de notre formation LangChain : c’est un parfait cas d’usage pour découvrir un framework LLM. Construire des RAG en entreprise est aussi une prestation clé de notre agence IA.

Étape 2 : Maîtriser les embeddings et la recherche sémantique

Pour implémenter un RAG, le second concept à maîtriser est la transformation du texte en langage naturel en représentations vectorielles. Ces “embeddings” ou vecteurs sémantiques capturent le sens des mots, mais dans un format informatique, c’est-à-dire un tableau de taille fixe.

Par exemple, si “adopter un chat” donne l’embedding [1,2,1], alors “refuge SPA” va donner un tableau avec des chiffres proches, par exemple [1,3,0], tandis que “prochain train pour Montpellier” va donner [42,25,30], avec des chiffres qui n’ont rien à voir.

Les embeddings permettent aux systèmes de trouver des contenus conceptuellement similaires, et dépassent donc les systèmes fondés sur les mots-clés qui sont en difficulté pour gérer des textes complexes ou même des synonymes.

En termes de code, voici un exemple simple de création d’embeddings avec LangChain et le modèle d’embedding de Gemini Generative AI (que l’on peut essayer gratuitement) :

from langchain_google_genai import GoogleGenerativeAIEmbeddings

embeddings = GoogleGenerativeAIEmbeddings(model="models/gemini-embedding-001")
vector = embeddings.embed_query("hello, world!")
vector[:5]
# vector est maintenant une représentation numérique du sens du texte

La recherche sémantique diffère de la recherche traditionnelle en se concentrant sur l’intention et le sens plutôt que sur la simple correspondance de termes. Cela permet une récupération d’informations efficace.

Néanmoins dans une base de données vectorielle avancée comme Milvus, on va cumuler plusieurs stratégies et plusieurs algorithmes pour avoir des résultats vraiment excellents.

Sur le plan technique, les embeddings sont calculés par des modèles d’apprentissage de représentation. Par exemple Matryoshka est un puissant modèle d’embedding qui permet de gérer des embeddings de taille variables. On peut ainsi optimiser le rapport coût/précision des embeddings simplement en choissant leur longueur.

Étape 3 : Charger des documents avec LangChain

LangChain fournit une interface standardisée pour toute la chaîne de traitement des documents :

Document Loaders pour charger les données brutes et les interpréter
Text splitters pour découper les gros documents en morceaux (“chunks”) plus petits
Vector store pour représenter une base de données vectorielle quelconque
Retrievers pour charger les données d’une base vectorielle ou toute autre source

Voici un exemple de chargement de données CSV :

# Chargement d'un document
from langchain_community.document_loaders.csv_loader import CSVLoader
loader = CSVLoader(file_path="./example_data/mlb_teams_2012.csv")
# On obtient un tableau d'objets Document 
# dans un format standardisé par LangChain
# On peut aussi utiliser "load_and_split" pour procéder directement
# à un découpage du texte s'il est trop long
documents = loader.load()
# On peut maintenant continuer le pipeline :
# - calculer des embeddings pour les documents
# - les stocker dans une base vectorielle
print(documents)

Ce qui change avec la v1 de LangChain : dans une application LangChain moderne, on évite de recourir trop systématiquement à ces abstractions. Elles sont pratiques si vous n’avez pas encore décidé de votre stack technologique, mais il n’est jamais bon de créer des surcouches trop abstraites.

Par exemple, dans la toute dernière version de notre formation LangChain, nous utilisons directement le SDK de Chroma plutôt qu’un Vector Store qui complique le code.

Étape 4 : Ingérer les documents pour les stocker dans une base de données vectorielle

Les bases de données vectorielles stockent les embeddings de documents, et fournissent ensuite des opérations de recherche sémantique rapides.

Lors de l’implémentation de votre pipeline RAG, vous devrez sélectionner une base de données vectorielle qui répond à vos besoins. Voici un exemple simple de configuration de Chroma, une base de données vectorielle populaire, avec LangChain :

from langchain_chroma import Chroma

vector_store = Chroma(
    collection_name="example_collection",
    embedding_function=embeddings,
	# Stockage local des données
    persist_directory="./chroma_langchain_db",  
)
uuids = [str(uuid4()) for _ in range(len(documents))]
vector_store.add_documents(documents=documents, ids=uuids)

# Recherche de 3 documents similaires à la requête
docs = db.similarity_search("How do I use LangChain?", k=3)

La base de données s’occupe de tous les aspects algorithmiques. Elle peut notamment calculer elle-même les embeddings, ou vous laisser fournir des embeddings déjà calculés, selon la situation.

Si vous êtes passionés par les algorithmes, vous pouvez approfondir vos connaissances en découvrant l’algorithme HSNW décrit en détail par les équipes de Pinecone. Il est notamment implémenté dans la librairie open source FAISS pour la recherche rapide de données vectorielles.

Finalisation : Implémenter un pipeline RAG complet

La construction d’un système RAG de bout en bout nécessite de connecter les composants évoqués jusqu’à présent en un pipeline cohérent.

Lorsque l’utilisateur déclenche une requête, il s’agit tout simplement d’enrichir cette requête en s’appuyant sur des documents pertinents, récupérés dans la base de données vectorielles via une recherche sémantique.

Le processus d’implémentation comprend finalement :

La création de workflows d’ingestion de documents (étape préliminaire obligatoire)
Le traitement des requêtes via des modèles d’embedding, pour pouvoir comparer la question de l’utilisateur et les documents en base de données
La récupération du contexte pertinent avec un moteur sémantique, pour créer un prompt qui contient la question de l’utilisateur mais aussi les sources pour y répondre : c’est l’Augmentation de la Requête (partie “RA” de “RAG”)
Enfin générer la réponse (le “G” de “RAG”)

Lorsqu’un utilisateur soumet une requête, votre système identifie les informations pertinentes en comparant l’embedding de la requête avec les embeddings des documents stockés. Il transmet ensuite le contexte enrichi à un LLM.

Voici le résultat final sous forme de code Python :

import chromadb
def rag(user_query):
	chroma_client = chromadb.Client()
	collection = chroma_client.get_collection(name="langchain_documentation")
  	results = langchain_documents_collection.query(
        query_texts=[query],
        n_results=1)["documents"][0]
 	augmented_prompt=f"""
    User question:
    {user_query}
    Relevant docs:
    {"\n---\n".join(results)}
  """
  return model.invoke(augmented_prompt).content

Si vous voulez découvrir des architectures RAG beaucoup plus élaborées, la publication de recherche de Gao et al. est une revue de littérature incontournable recensant de nombreux systèmes RAG.

Nouveau avec LangChain v1 : le RAG agentique

Une autre approche du RAG consiste à laisser le LLM décider automatiquement de s’il faut ou non réaliser une recherche de documents.

Avant octobre 2025, il faurait fallu utiliser LangGraph, le framework agentique avancé qui complète LangChain. Mais LangGraph est beaucoup plus complexe.

Aujourd’hui, on peut créer une boucle agentique (formellemment, un agent ReAct) directement avec la fonction create_agent de LangChain, et lui fournir un outil de recherche dans une base de données.

C’est le fameux RAG agentique.

Pas besoin de découvrir un nouveau framework, LangChain suffit à créer vos premiers agents d’IA en plus de gérer toute la connexion à une API LLM et une base de données vectorielle.


# Connexion à une API LLM
from langchain.chat_models import init_chat_model
# create_agent est tout nouveau dans la v1 !
from langchain.agents import create_agent
# Créer des outils (pas besoin de MCP, juste de Python)
from langchain.tools import tool
# L'outil se connecte à Internet via HTTP
import requests

# Notre outil RAG qui peut télécharger une URL
@tool
def fetch_url(url: str) -> str:
    """Fetch text content from a URL"""
    response = requests.get(url, timeout=10.0)
    response.raise_for_status()
    return response.text

system_prompt = """\
Use fetch_url when you need to fetch information from a web-page; quote relevant snippets.
"""

# Notre agent
agent = create_agent(
    model="claude-sonnet-4-5-20250929",
    # Outil de recherche = c'est un RAG agentique !
    tools=[fetch_url],
    system_prompt=system_prompt,
)

Ce RAG agentique avec LangChain est vraiment très basique, il a tendance à halluciner des URL et ne sait pas bien analyser le contenu HTML.

Pour aller plus loin, il est courant de connecter l’IA à un moteur de recherche en plus de vos données d’entreprise, par exemple via l’API Tavily pour créer un RAG hybride.

Post-implémentation: Surveiller les performances avec LangSmith

Les systèmes RAG, comme toutes les applications fondées sur les LLM nécessitent une surveillance et une optimisation continues. L’implémentation n’était que la première étape du travail !

LangSmith est la partie commerciale de l’écosystème LangChain, et fournit des outils pour suivre vos applications IA, vous aidant à identifier et résoudre les problèmes dans vos processus de retrieval et de génération.

Nous mettons en place LangSmith dès le début de notre formation LangChain, avant même d’aborder la création d’agents en combinant LangChain et LangGraph.

Découvrir le RAG étape par étape et aller plus loin

En maîtrisant chaque composant du RAG — embedding, récupération, génération et monitoring — vous développerez les compétences pour créer des applications d’IA plus fiables.

Implémenter une architecture RAG avec LangChain constitue un excellent exercice d’apprentissage pour découvrir le développement LLM en général. Il s’agit d’après nous du point de départ idéal pour une formation LangChain, car le RAG est un peu de le “hello world” des workflows agentique.

Le RAG simple et le RAG agentique ne sont que des points de départ, chaque étape du RAG peut être optimisé. Cette ressource de Hub France IA sur le RAG vous aidera à mieux évaluer votre marge de progression sur chaque étape. Le paradigme RAG continue d’évoluer, avec des développements dans les implémentations multimodales qui peuvent traiter à la fois du texte et des images.

Vous l’avez peut-être déjà deviné, mais la version initiale de cet article a été en grande partie généré à l’aide d’une architecture RAG couplant LangChain, Tavily, et nos propres contenus de formation LangChain !

Les experts SEO l’auront aussi compris, les résultats de recherche sont désormais destinés à être consommés par des RAG, aussi bien Perplexity que les nouvelles fonctionnalités d’aperçu et de recherche IA de Google.

Un article de Forbes explique par exemple comment les principes E-A-T (Expertise, Authoritativeness, Trustworthiness) deviennent cruciaux avec l’émergence de moteurs de recherche fondés sur les LLM.

Le RAG est un pilier fondamental de l’IA agentique : vous savez désormais comment le mettre en oeuvre avec LangChain !

Créer un RAG avec LangChain en 5 étapes (à jour pour la v1 avec le RAG agentique)