Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

RAG Frameworks: LangChain, LlamaIndex, Haystack

Les 18 van 18 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Voorbij de RAG vanaf nul
  2. LangChain met Mistral
  3. LlamaIndex met Mistral
  4. Haystack met Mistral
  5. Welke kiezen?
  6. Volgende stappen
  7. Belangrijkste punten
  8. Test uw kennis

Voorbij de RAG vanaf nul

U heeft een complete RAG-pijplijn in zuiver Python gebouwd, en dat was de juiste aanpak: u weet nu wat elke regel doet, waar uitlijnfouten zich verstoppen en waarom een slecht opgesplitste chunk een antwoord verpest. In productie kunt u ook leunen op gespecialiseerde frameworks die het technische loden werk beheren en geavanceerde functionaliteit toevoegen. De drie belangrijkste—LangChain, LlamaIndex en Haystack—zijn allemaal compatibel met Mistral AI, en de keuze tussen hen hangt minder van de kwaliteit af dan van het type toepassing dat u voor ogen heeft.

LangChain met Mistral

LangChain is het populairste framework voor LLM-toepassingen. De belangrijkste kracht zit in de omvang van het integratie-ecosysteem, aangevuld met de module LangGraph voor geavanceerde stroomcontroles. De installatie bundelt de kern, de Mistral-connector, de community-integraties en FAISS.

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

De minimale RAG past dan in een dertigtal regels, en het doel is te zien wat er verdwenen is ten opzichte van uw handmatige implementatie. Het batchen, de retries, de conversie naar float32, de uitlijning tussen vectoren en metadata: dat wordt allemaal overgenomen door FAISS.from_texts. De RecursiveCharacterTextSplitter vervangt uw splitfuncties met dezelfde parameters als eerder, 1500 tekens en 200 overlap. De uiteindelijke keten schrijft u met de pipe-operator, die de stappen van links naar rechts samenstelt: de retriever voedt de context, RunnablePassthrough laat de vraag ongewijzigd doorstromen, de prompt voegt ze samen, het model genereert en de parser extraert de tekst.

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

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

# Découpage et indexation
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Création du vector store
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# Chaîne RAG
prompt = ChatPromptTemplate.from_template(
    """Context: {context}

Question: {question}

Answer based on the context."""
)

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

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

LangGraph voor Corrective, Auto en Adaptatieve RAG

De lineaire keten hierboven werkt voor een standaard RAG, maar kan niet lussen of aftakken—toch doen de architecturen uit de drie voorgaande lessen precies dat. LangGraph beantwoordt deze behoefte door stroomcontroles als graphen te definiëren. De getypeerde GraphState werkt als gedeeld geheugen: elke node ontvangt het, leest wat nodig is en geeft de velden terug die hij bijwerkt. U herkent uw eigen functies achter retrieve_node, grade_node en generate_node, met grade_document ongewijzigd hergebruikt.

Het echt nieuwe mechanisme is add_conditional_edges. Waar uw Python-klasse if-instructies aaneenreeg, verklaart de graph een beslissingsfunctie—hier route_after_grade—en de tabel van mogelijke bestemmingen. Deze scheiding tussen de bedrijfslogica van de nodes en de topologie van de stroom maakt de pijplijn in één oogopslag leesbaar en aanpasbaar zonder de code van de stappen aan te raken. Eenmaal gecompileerd roept u de graph aan als een gewone functie.

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):
    """Nœud de récupération."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Nœud d'évaluation des documents."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Utilisation du LLM pour évaluer la pertinence
        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):
    """Nœud de génération."""
    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):
    """Décision conditionnelle après évaluation."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Construction du graphe
workflow = StateGraph(GraphState)

# Ajout des nœuds
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Définition du flux
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)

# Compilation
app = workflow.compile()

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

LlamaIndex met Mistral

LlamaIndex duwt de abstractie verder door omdat het specifiek geoptimaliseerd is voor RAG en voor het beheer van gestructureerde documenten.

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

De configuratie gebeurt via een globaal object Settings dat één keer voor al het generatiemodel en het embeddingmodel vastlegt. SimpleDirectoryReader laadt een hele map door de formaten te raden, en VectorStoreIndex.from_documents ketent het splitsen en encoderen zonder dat u ze hoeft in te stellen. De winst in beknoptheid is echt, maar weeg wat dit inhoudt: de splitsstrategie, waarvan u nu weet dat ze de kwaliteit van de retrieval bepaalt, wordt hier voor u gekozen. Fijntjes om mee te beginnen, en de eerste instelling die u terug in eigen hand moet nemen op de dag dat de antwoorden tegenvallen. Merk op dat response.source_nodes de metadata behoudt, dus de traceerbaarheid die u handmatig had geïmplementeerd.

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

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

# Chargement des documents
documents = SimpleDirectoryReader("./data/").load_data()

# Création de l'index (découpage + embedding automatiques)
index = VectorStoreIndex.from_documents(documents)

# Création du moteur de requête
query_engine = index.as_query_engine(similarity_top_k=3)

# Poser une 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 met Mistral

Haystack, ontwikkeld door deepset, kiest een derde filosofie: die van modulaire pijplijnen, waarin elke component een naam krijgt, wordt toegevoegd en vervolgens expliciet met zijn buren verbonden.

pip install haystack-ai mistral-haystack

De indexeringspijplijn hieronder illustreert deze aanpak goed. Drie componenten worden gedeclareerd—de splitter, de encoder via MistralDocumentEmbedder en de writer naar de document store—en vervolgens verbonden via connect-aanroepen die de gegevensstroom in de code zichtbaar maken. Deze brede woordkeus, die zinloos kan lijken bij een eenvoudig geval, wordt een troef zodra de pijplijn vertakt of u een schakel moet vervangen zonder de andere aan te raken. Let ook op het onderscheid tussen MistralDocumentEmbedder en MistralTextEmbedder: de eerste codeert documenten bij het indexeren, de tweede codeert vragen bij het bevragen, een scheiding die de klassieke fout vermijdt om beide op dezelfde manier te behandelen.

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()

# Pipeline d'indexation
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")

Welke kiezen?

Elk framework heeft eigen sterke punten, en de tabel hieronder vat de afweging samen.

FrameworkBelangrijkste krachtIdeale toepassing
LangChainRijkste ecosysteem, LangGraph voor complexe stroomcontrolesAgents en geavanceerde RAG
LlamaIndexEenvoudigste voor RAG, native verwerking van gestructureerde documentenSnelle start, beginners
HaystackModulaire pijplijnaanpak, sterk bij evaluatieUitrol in productie

Volgende stappen

U beschikt nu over alle basiskennis om RAG-systemen met Mistral AI te bouwen. U weet tekst te encoderen met mistral-embed en zijn 1024 dimensies, code te encoderen met codestral-embed en instelbare dimensies tot 3072, een RAG vanaf nul te bouwen op FAISS en de Mistral API, en die te versterken met Corrective-, Self- en Adaptive-architecturen. Deze laatste les voegt de weg van de frameworks toe: LangChain, LlamaIndex en Haystack.

Voor verdieping vindt u de officiële Mistral AI cookbooks en de notebooks van elk framework, die de ontwikkeling van de API’s van dichterbij volgen dan welke cursus dan ook. RAG is een snel evoluerend domein: splits-, retrieval- en verificatietechnieken blijven verbeteren, en juist omdat u elke stap met de hand heeft geschreven, zult u de volgende kunnen beoordelen zodra die verschijnt.

Belangrijkste punten

  • LangChain + LangGraph is de eerste keuze voor geavanceerde RAG-stroomcontroles
  • LlamaIndex is het eenvoudigst voor een standaard RAG met Mistral
  • Haystack blinkt uit in modulariteit en pijplijn-evaluatie
  • Alle drie frameworks ondersteunen native mistral-embed en mistral-large
  • Begin met een RAG vanaf nul om te begrijpen, migreer dan naar een framework voor productie

Test uw kennis

Embeddings, RAG en geavanceerde varianten: het grote eindexamen.

1. Welke twee embeddingmodellen heeft Mistral en waar dienen ze voor?

Antwoord: mistral-embed voor algemene tekst, codestral-embed voor code—elk projecteert zijn domein in een ruimte waarin semantische gelijkenis wordt gemeten.

2. Welke stappen vormen de RAG-pijplijn van de cursus?

Antwoord: Gegevens voorbereiden (splitsen), embeddings creëren, ze opslaan in een vector store (FAISS), dan retrieval + generatie: de vraag vindt zijn passages, het model beantwoordt op basis daarvan.

3. Wat herstelt Corrective RAG?

Antwoord: Slechte retrievals: het evalueert de relevantie van de opgehaalde passages en lost een correctie (nieuwe zoekopdracht, hervormulering) af alvorens te genereren—in plaats van op ruis te antwoorden.

4. Self-RAG en Adaptive RAG: welk idee delen ze?

Antwoord: De pijplijn reflectief maken: beslissen wanneer je retrieved, eigen outputs bekritiseren, de strategie aan de vraag aanpassen—RAG stopt met een vaste buis te zijn.

5. Wat brengen LangChain, LlamaIndex of Haystack?

Antwoord: Gereedschap: kant-en-klare componenten voor inname, indexen, ketens en evaluatie—nuttig voor snelheid, mits u begrijpt wat ze ineenzetten (wat deze cursus u geleerd heeft).

U weet nu een RAG met de hand te bouwen en met kennis van zaken aan een framework toe te vertrouwen—dat is de juiste volgorde.