Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

RAG Frameworks: LangChain, LlamaIndex, Haystack

Nodarbība 18 no 18 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Au-delà du RAG from Scratch
  2. LangChain avec Mistral
  3. LlamaIndex avec Mistral
  4. Haystack avec Mistral
  5. Lequel choisir ?
  6. Prochaines étapes
  7. Galvenās atziņas
  8. Teste tes connaissances

Au-delà du RAG from Scratch

Tu as construit un pipeline RAG complet en Python pur, et c’était la bonne démarche : tu sais maintenant ce que fait chaque ligne, où se cachent les erreurs d’alignement et pourquoi un chunk mal découpé ruine une réponse. En production, tu peux aussi t’appuyer sur des frameworks spécialisés qui gèrent la plomberie et ajoutent des fonctionnalités avancées. Les trois principaux — LangChain, LlamaIndex et Haystack — sont tous compatibles avec Mistral AI, et le choix entre eux dépend moins de la qualité que du type d’application que tu vises.

LangChain avec Mistral

LangChain est le framework le plus populaire pour les applications LLM. Sa force principale réside dans l’étendue de son écosystème d’intégrations, complété par le module LangGraph pour les flux de contrôle avancés. L’installation regroupe le cœur, le connecteur Mistral, les intégrations communautaires et FAISS.

pip install langchain langchain-mistralai langchain-community faiss-cpu

Le RAG minimal tient alors en une trentaine de lignes, et l’objectif est de voir ce qui a disparu par rapport à ton implémentation manuelle. Le batching, les retries, la conversion en float32, l’alignement entre vecteurs et métadonnées : tout cela est absorbé par FAISS.from_texts. Le RecursiveCharacterTextSplitter remplace tes fonctions de découpage avec les mêmes paramètres qu’avant, 1500 caractères et 200 de chevauchement. La chaîne finale s’écrit avec l’opérateur pipe, qui compose les étapes de gauche à droite : le retriever alimente le contexte, RunnablePassthrough fait circuler la question telle quelle, le prompt les assemble, le modèle génère et le parser extrait la chaîne.

from langchain_mistralai import ChatMistralAI, MistralAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# Mistral models
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)

# Splitting and indexing
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Create the vector store
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# RAG chain
prompt = ChatPromptTemplate.from_template(
    """Context: {context}

Question: {question}

Answer based on the context."""
)

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

# Usage
answer = rag_chain.invoke("How does FAISS work?")
print(answer)

LangGraph pour le RAG Correctif, Auto et Adaptatif

La chaîne linéaire ci-dessus fonctionne pour un RAG standard, mais elle ne peut ni boucler ni bifurquer — or c’est exactement ce que font les architectures des trois dernières leçons. LangGraph répond à ce besoin en définissant des flux de contrôle sous forme de graphes. Le GraphState typé agit comme une mémoire partagée : chaque nœud le reçoit, lit ce dont il a besoin et renvoie les champs qu’il met à jour. Tu reconnaîtras tes propres fonctions derrière retrieve_node, grade_node et generate_node, avec grade_document réutilisé tel quel.

Le mécanisme vraiment nouveau est add_conditional_edges. Là où ta classe Python enchaînait des instructions if, le graphe déclare une fonction de décision — ici route_after_grade — et le tableau des destinations possibles. Cette séparation entre la logique métier des nœuds et la topologie du flux rend le pipeline lisible d’un coup d’œil et modifiable sans toucher au code des étapes. Une fois compilé, le graphe s’invoque comme une simple fonction.

from langgraph.graph import StateGraph, END
from typing import TypedDict

class GraphState(TypedDict):
    question: str
    documents: list
    generation: str
    web_search_needed: bool

def retrieve_node(state):
    """Retrieval node."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Document grading node."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Use the LLM to evaluate relevance
        grade = grade_document(question, doc.page_content)
        if grade:
            relevant.append(doc)
        else:
            web_needed = True

    return {"documents": relevant, "web_search_needed": web_needed}

def generate_node(state):
    """Generation node."""
    question = state["question"]
    docs = state["documents"]
    context = "\n\n".join([d.page_content for d in docs])
    generation = llm.invoke(f"Context: {context}\n\nQuestion: {question}")
    return {"generation": generation.content}

def route_after_grade(state):
    """Conditional decision after grading."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Build the graph
workflow = StateGraph(GraphState)

# Add nodes
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Define the flow
workflow.set_entry_point("retrieve")
workflow.add_edge("retrieve", "grade")
workflow.add_conditional_edges("grade", route_after_grade, {
    "generate": "generate",
    "web_search": "web_search",
})
workflow.add_edge("generate", END)

# Compile
app = workflow.compile()

# Execute
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])

LlamaIndex avec Mistral

LlamaIndex pousse l’abstraction plus loin car il est optimisé spécifiquement pour le RAG et la gestion de documents structurés.

pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai

La configuration se fait via un objet global Settings qui définit une fois pour toutes le modèle de génération et le modèle d’embedding. SimpleDirectoryReader charge tout un répertoire en devinant les formats, et VectorStoreIndex.from_documents enchaîne découpage et encodage sans que tu aies à les paramétrer. Le gain en concision est réel, mais mesure ce que cela implique : la stratégie de découpage, dont tu sais maintenant qu’elle détermine la qualité de la récupération, est choisie pour toi ici. C’est confortable pour débuter, et c’est le premier réglage que tu devras reprendre en main le jour où les réponses décevront. Note que response.source_nodes préserve les métadonnées, d’où la traçabilité que tu as implémentée manuellement.

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.mistralai import MistralAI
from llama_index.embeddings.mistralai import MistralAIEmbedding
from llama_index.core import Settings

# Global configuration
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")

# Load documents
documents = SimpleDirectoryReader("./data/").load_data()

# Create the index (automatic chunking + embedding)
index = VectorStoreIndex.from_documents(documents)

# Create the query engine
query_engine = index.as_query_engine(similarity_top_k=3)

# Ask a question
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")

Haystack avec Mistral

Haystack, développé par deepset, adopte une troisième philosophie : celle des pipelines modulaires, où chaque composant est nommé, ajouté, puis explicitement connecté à ses voisins.

pip install haystack-ai mistral-haystack

Le pipeline d’indexation ci-dessous illustre bien cette approche. Trois composants sont déclarés — le splitter, l’encodeur via MistralDocumentEmbedder et le writer vers le store de documents — puis reliés par des appels connect qui rendent le flux de données visible dans le code. Cette verbosité, qui peut sembler inutile sur un cas simple, devient un atout dès que le pipeline se bifurque ou que tu dois remplacer un maillon sans toucher aux autres. Note aussi la distinction entre MistralDocumentEmbedder et MistralTextEmbedder : le premier encode les documents au moment de l’indexation, le second encodera les requêtes au moment de l’interrogation, une séparation qui évite l’erreur classique de traiter les deux de la même manière.

from haystack import Pipeline
from haystack.components.writers import DocumentWriter
from haystack.components.preprocessors import DocumentSplitter
from haystack_integrations.components.embedders.mistral import (
    MistralDocumentEmbedder,
    MistralTextEmbedder,
)
from haystack_integrations.components.generators.mistral import MistralChatGenerator
from haystack.document_stores.in_memory import InMemoryDocumentStore

# Document store
doc_store = InMemoryDocumentStore()

# Indexing pipeline
indexing_pipeline = Pipeline()
indexing_pipeline.add_component("splitter", DocumentSplitter(
    split_by="passage", split_length=5
))
indexing_pipeline.add_component("embedder", MistralDocumentEmbedder(
    model="mistral-embed"
))
indexing_pipeline.add_component("writer", DocumentWriter(
    document_store=doc_store
))

indexing_pipeline.connect("splitter", "embedder")
indexing_pipeline.connect("embedder", "writer")

Lequel choisir ?

Chaque framework a ses forces, et le tableau ci-dessous résume le compromis.

FrameworkForce principaleCas d’usage idéal
LangChainÉcosystème le plus riche, LangGraph pour les flux de contrôle complexesAgents et RAG avancé
LlamaIndexLe plus simple pour le RAG, gestion native des documents structurésDémarrage rapide, débutants
HaystackApproche par pipelines modulaires, fort sur l’évaluationDéploiement en production

Prochaines étapes

Tu as maintenant toutes les bases pour construire des systèmes RAG avec Mistral AI. Tu sais encoder du texte avec mistral-embed et ses 1024 dimensions, encoder du code avec codestral-embed et ses dimensions configurables jusqu’à 3072, construire un RAG from scratch sur FAISS et l’API Mistral, puis le durcir avec des architectures Corrective, Self et Adaptive. Cette dernière leçon ajoute la voie des frameworks : LangChain, LlamaIndex et Haystack.

Pour aller plus loin, explore les cookbooks officiels de Mistral AI ainsi que les notebooks de chaque framework, qui suivent l’évolution des API de plus près que n’importe quel cours. Le RAG est un domaine en évolution rapide : les techniques de découpage, de récupération et de vérification s’améliorent constamment, et c’est précisément parce que tu as écrit chaque étape à la main que tu seras capable d’évaluer la prochaine qui apparaîtra.

Galvenās atziņas

  • LangChain + LangGraph est le premier choix pour les flux de contrôle RAG avancés
  • LlamaIndex est le plus simple pour un RAG standard avec Mistral
  • Haystack excelle en modularité et en évaluation de pipelines
  • Les trois frameworks supportent nativement mistral-embed et mistral-large
  • Commence par un RAG from scratch pour comprendre, puis migre vers un framework pour la production

Teste tes connaissances

Embeddings, RAG et variantes avancées : le grand examen final.

1. Quels sont les deux modèles d'embedding de Mistral et à quoi servent-ils ?

Réponse : mistral-embed pour le texte général, codestral-embed pour le code — chacun projette son domaine dans un espace où la similarité sémantique est mesurée.

2. Quelles étapes composent le pipeline RAG du cours ?

Réponse : Préparer les données (découpage), créer les embeddings, les stocker dans un vector store (FAISS), puis retrieval + génération : la question trouve ses passages, le modèle répond en se basant dessus.

3. Que corrige le Corrective RAG ?

Réponse : Les mauvaises récupérations : il évalue la pertinence des passages récupérés et déclenche une correction (nouvelle recherche, reformulation) avant de générer — au lieu de répondre sur du bruit.

4. Self-RAG et Adaptive RAG : quelle est l'idée commune ?

Réponse : Rendre le pipeline réflexif : décider quand récupérer, critiquer ses propres sorties, adapter la stratégie à la question — le RAG cesse d’être un tuyau fixe.

5. Qu'apportent LangChain, LlamaIndex ou Haystack ?

Réponse : De l’outillage : des composants prêts à l’emploi pour l’ingestion, les index, les chaînes et l’évaluation — utiles pour la vitesse, à condition de comprendre ce qu’ils assemblent (ce que ce cours t’a appris).

Tu sais maintenant construire un RAG à la main et le confier à un framework en toute connaissance de cause — c’est le bon ordre.