RAG-rammer: LangChain, LlamaIndex, Haystack
På denne side
Ud over RAG fra bunden
Du har bygget en komplet RAG-pipeline i ren Python, og det var den rigtige vej: Nu ved du, hvad hver linje gør, hvor justeringsfejl gemmer sig, og hvorfor en dårligt udskåret tekstbid ødelægger et svar. I produktion kan du også stole på specialiserede rammer, der håndterer det tekniske grundarbejde og tilføjer avancerede funktioner. De tre vigtigste—LangChain, LlamaIndex og Haystack—er alle kompatible med Mistral AI, og valget mellem dem afhænger mindre af kvalitet end af den type applikation, du målretter mod.
LangChain med Mistral
LangChain er den mest populære ramme til LLM-applikationer. Dens største styrke er bredden af sit integrationsøkosystem, suppleret af modulet LangGraph til avancerede kontrolflow. Installationspakken indeholder kernen, Mistral-stikket, community-integrationer og FAISS.
pip install langchain langchain-mistralai langchain-community faiss-cpu
Den minimale RAG passer derefter ind på omkring tredive linjer, og pointen er at se, hvad der er forsvundet sammenlignet med din manuelle implementering. Batch-behandling, genforsøg, konvertering til float32, justering mellem vektorer og metadata: alt dette absorberes af FAISS.from_texts. RecursiveCharacterTextSplitter erstatter dine chunking-funktioner med de samme parametre som før: 1500 tegn og 200 i overlap. Den endelige kæde skrives med pipe-operatoren, som sammensætter trin fra venstre mod højre: retrieveren leverer konteksten, RunnablePassthrough cirkulerer spørgsmålet uændret, prompten samler dem, modellen genererer, og parseren udtrækker strengen.
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-modeller
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)
# Opdeling og indeksering
splitter = RecursiveCharacterTextSplitter(
chunk_size=1500,
chunk_overlap=200,
)
chunks = splitter.split_text(document_text)
# Opret vector store
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# RAG-kæde
prompt = ChatPromptTemplate.from_template(
"""Context: {context}
Question: {question}
Answer based on the context."""
)
rag_chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# Brug
answer = rag_chain.invoke("How does FAISS work?")
print(answer)
LangGraph til korrigerende, selvreflekterende og adaptiv RAG
Den lineære kæde ovenfor fungerer til standard-RAG, men den kan ikke lave løkker eller forgreninger—og det er netop, hvad arkitekturerne i de foregående tre lektioner gør. LangGraph imødekommer dette behov ved at definere kontrolflow som grafer. Den typede GraphState fungerer som delt hukommelse: hver node modtager den, læser det, den har brug for, og returnerer de felter, den opdaterer. Du vil genkende dine egne funktioner bag retrieve_node, grade_node og generate_node, hvor grade_document genbruges uændret.
Den virkelig nye mekanisme er add_conditional_edges. Hvor din Python-klasse kædede if-sætninger sammen, erklærer grafen en beslutningsfunktion—her route_after_grade—og tabellen over mulige destinationer. Denne adskillelse mellem nodernes forretningslogik og flow-topologien gør pipelinen læselig ved første øjekast og modificerbar uden at røre ved selve step-koden. Når den er kompileret, kaldes grafen som en simpel funktion.
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:
# Brug LLM til at evaluere relevans
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):
"""Genererings-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):
"""Betinget beslutning efter grading."""
if state["web_search_needed"]:
return "web_search"
return "generate"
# Byg grafen
workflow = StateGraph(GraphState)
# Tilføj noder
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)
# Definer flowet
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)
# Kompilér
app = workflow.compile()
# Eksekvér
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])
LlamaIndex med Mistral
LlamaIndex driver abstraktionen endnu videre, fordi den er optimeret specifikt til RAG og struktureret dokumenthåndtering.
pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai
Konfigurationen sker via et globalt Settings-objekt, der sætter genereringsmodellen og embedding-modellen én gang for alle. SimpleDirectoryReader indlæser en hel mappe ved at gætte formater, og VectorStoreIndex.from_documents kæder chunking og kodning sammen, uden at du behøver at parametrisere dem. Gevinsten i koncision er reel, men mål hvad det indebærer: Split-strategien, som du nu ved afgør kvaliteten af retrieval, vælges her for dig. Det er komfortabelt til at komme i gang, og det er den første indstilling, du får brug for at tage tilbage i egen hånd den dag, svarene skuffer. Bemærk, at response.source_nodes bevarer metadata, hvilket giver den sporbarhed, du implementerede manuelt.
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 konfiguration
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")
# Indlæs dokumenter
documents = SimpleDirectoryReader("./data/").load_data()
# Opret indekset (automatisk chunking + embedding)
index = VectorStoreIndex.from_documents(documents)
# Opret query-engine
query_engine = index.as_query_engine(similarity_top_k=3)
# Stil et spørgsmål
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")
Haystack med Mistral
Haystack, udviklet af deepset, adopterer en tredje filosofi: den om modulære pipelines, hvor hver komponent navngives, tilføjes og derefter eksplicit forbindes til sine naboer.
pip install haystack-ai mistral-haystack
Indekseringspipelinen nedenfor illustrerer denne tilgang godt. Tre komponenter erklæres—splitteren, encoderen via MistralDocumentEmbedder og skriveren til dokumentlageret—og linkes derefter via connect-kald, der gør dataflowet synligt i koden. Denne verbositet, som kan virke unødvendig i et simpelt tilfælde, bliver en aktiv, så snart pipelinen forgrener sig, eller du skal udskifte et led uden at røre ved de andre. Bemærk også sondringen mellem MistralDocumentEmbedder og MistralTextEmbedder: den første koder dokumenter ved indekseringstidspunktet, den anden vil kode forespørgsler ved søgetidspunktet; en adskillelse, der forhindrer den klassiske fejl at behandle begge på samme måde.
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
# Dokumentlager
doc_store = InMemoryDocumentStore()
# Indekseringspipeline
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")
Hvilken skal du vælge?
Hver ramme har sine styrker, og tabellen nedenfor opsummerer afvejningen.
| Ramme | Hovedstyrke | Sweet Spot |
|---|---|---|
| LangChain | Rigeste økosystem, LangGraph til komplekse kontrolflow | Agenter og avanceret RAG |
| LlamaIndex | Enklest til RAG, native håndtering af strukturerede dokumenter | Hurtig start, begyndere |
| Haystack | Modulær pipeline-tilgang, stærk til evaluering | Implementering i produktion |
Næste skridt
Du har nu alle grundstenene til at bygge RAG-systemer med Mistral AI. Du ved, hvordan man koder tekst med mistral-embed og dets 1024 dimensioner, koder kode med codestral-embed og dets konfigurerbare dimensioner op til 3072, bygger en RAG fra bunden på FAISS og Mistral API’en, og derefter hærder den med korrigerende, selvreflekterende og adaptive arkitekturer. Denne sidste lektion tilføjer vejen via rammer: LangChain, LlamaIndex og Haystack.
For at gå videre bør du udforske de officielle Mistral AI-cookbooks samt notebooks for hver ramme, som følger API-udviklingen tættere end noget kursus. RAG er et felt i hastig udvikling: teknikker til chunking, retrieval og verifikation forbedres konstant, og det er netop fordi, du har skrevet hvert trin i hånden, at du vil kunne evaluere den næste, der dukker op.
Vigtige pointer
- LangChain + LangGraph er det primære valg til avancerede RAG-kontrolflow
- LlamaIndex er den enkleste til standard-RAG med Mistral
- Haystack excellerer i modularitet og pipeline-evaluering
- Alle tre rammer understøtter nativt mistral-embed og mistral-large
- Start med RAG fra bunden for at forstå, migrér derefter til en ramme til produktion
Test din viden
Embeddings, RAG og avancerede varianter: den store finaleksamen.
1. Hvad er Mistrals to embedding-modeller, og hvad bruges de til?
Svar: mistral-embed til generel tekst, codestral-embed til kode—hver projicerer sit domæne ind i et rum, hvor semantisk lighed måles.
2. Hvilke trin udgør kursets RAG-pipeline?
Svar: Forbered data (chunking), opret embeddings, gem dem i et vector store (FAISS), derefter retrieval + generering: spørgsmålet finder sine passager, modellen svarer baseret på dem.
3. Hvad fikser Corrective RAG?
Svar: Dårlige retrievals: den evaluerer relevansen af hentede passager og udløser en korrektion (ny søgning, omformulering) før generering—i stedet for at svare på støj.
4. Self-RAG og Adaptive RAG: hvad er den fælles idé?
Svar: Gør pipelinen refleksiv: beslut hvornår der skal hentes data, kritisér sine egne outputs, tilpas strategien til spørgsmålet—RAG holder op med at være et fast rør.
5. Hvad bringer LangChain, LlamaIndex eller Haystack?
Svar: Værktøjer: færdige komponenter til ingestion, indeks, kæder og evaluering—nyttigt for hastighed, forudsat at du forstår, hvad de samler (hvilket dette kursus har lært dig).
Du ved nu, hvordan man bygger en RAG i hånden og overlader den til en ramme med fuld bevidsthed—det er den rigtige rækkefølge.