Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

RAG-ramverk: LangChain, LlamaIndex, Haystack

Lektion 18 av 18 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Utöver RAG från grunden
  2. LangChain med Mistral
  3. LlamaIndex med Mistral
  4. Haystack med Mistral
  5. Vilket ska du välja?
  6. Nästa steg
  7. Viktiga punkter
  8. Testa dina kunskaper

Utöver RAG från grunden

Du har byggt en komplett RAG-pipeline i ren Python, och det var rätt väg: du vet nu vad varje rad gör, var justeringsfel gömmer sig och varför en dåligt uppskuren bit förstör ett svar. I produktion kan du också förlita dig på specialiserade ramverk som sköter rörmokeriet och lägger till avancerade funktioner. De tre huvudsakliga – LangChain, LlamaIndex och Haystack – är alla kompatibla med Mistral AI, och valet mellan dem beror mindre på kvalitet än på vilken typ av applikation du siktar på.

LangChain med Mistral

LangChain är det mest populära ramverket för LLM-applikationer. Dess främsta styrka är bredden i dess integreringsekosystem, kompletterat med modulen LangGraph för avancerade kontrollflöden. Installationspaketet innehåller kärnan, Mistral-kontakten, community-integreringar och FAISS.

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

Den minimala RAG:n ryms sedan på cirka trettio rader, och poängen är att se vad som har försvunnit jämfört med din manuella implementation. Batchning, försök igen, konvertering till float32, justering mellan vektorer och metadata: allt detta absorberas av FAISS.from_texts. RecursiveCharacterTextSplitter ersätter dina chunking-funktioner med samma parametrar som tidigare, 1500 tecken och 200 i överlappning. Den slutgiltiga kedjan skrivs med pipe-operatorn, som komponerar steg från vänster till höger: retrievern matar kontexten, RunnablePassthrough cirkulerar frågan oförändrad, prompten sätter ihop dem, modellen genererar och parsaren extraherar strängen.

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)

# Uppdelning och indexering
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Skapa vektorlagret
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

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

Question: {question}

Answer based on the context."""
)

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

# Användning
answer = rag_chain.invoke("How does FAISS work?")
print(answer)

LangGraph för korrigerande, självgående och adaptiv RAG

Den linjära kedjan ovan fungerar för standard-RAG, men den kan inte loopa eller förgrena sig – ändå är det exakt vad arkitekturerna i de tre föregående lektionerna gör. LangGraph adresserar detta behov genom att definiera kontrollflöden som grafer. Den typade GraphState fungerar som delat minne: varje nod tar emot den, läser vad den behöver och returnerar de fält den uppdaterar. Du kommer att känna igen dina egna funktioner bakom retrieve_node, grade_node och generate_node, där grade_document återanvänds som den är.

Den verkligt nya mekanismen är add_conditional_edges. Där din Python-klass kedjade if-satser, deklarerar grafen en beslutsfunktion – här route_after_grade – och tabellen över möjliga destinationer. Denna separation mellan nodernas affärslogik och flödestopologin gör pipelinen läsbar vid en första anblick och modifierbar utan att röra stegkoden. När den väl är kompilerad anropas grafen som en enkel 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-nod."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Dokumentbetygsättningsnod."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Använd LLM för att utvärdera 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):
    """Genereringsnod."""
    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):
    """Villkorligt beslut efter betygsättning."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Bygg grafen
workflow = StateGraph(GraphState)

# Lägg till noder
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Definiera flödet
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)

# Kompilera
app = workflow.compile()

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

LlamaIndex med Mistral

LlamaIndex driver abstraktionen längre eftersom det är optimerat specifikt för RAG och hantering av strukturerade dokument.

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

Konfigurationen sker via ett globalt Settings-objekt som ställer in genereringsmodellen och inbäddningsmodellen en gång för alla. SimpleDirectoryReader läser in en hel katalog genom att gissa format, och VectorStoreIndex.from_documents kedjar chunking och kodning utan att du behöver parametrisera dem. Vinsten i koncisitet är verklig, men mät vad det innebär: uppdelningsstrategin, som du nu vet avgör retrieval-kvaliteten, väljs åt dig här. Det är bekvämt för att komma igång, och det är den första inställning du kommer att behöva ta tillbaka i egna händer den dag svaren sviker. Observera att response.source_nodes bevarar metadata, vilket ger den spårbarhet du implementerade manuellt.

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

# Läs in dokument
documents = SimpleDirectoryReader("./data/").load_data()

# Skapa indexet (automatisk chunking + inbäddning)
index = VectorStoreIndex.from_documents(documents)

# Skapa frågemotorn
query_engine = index.as_query_engine(similarity_top_k=3)

# Ställ en fråga
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, utvecklat av deepset, antar en tredje filosofi: den om modulära pipelines, där varje komponent namnges, läggs till och sedan explicit kopplas till sina grannar.

pip install haystack-ai mistral-haystack

Indexeringspipelinen nedan illustrerar detta tillvägagångssätt väl. Tre komponenter deklareras – splitter, kodaren via MistralDocumentEmbedder och skrivaren till dokumentlagret – och länkas sedan med connect-anrop som gör dataflödet synligt i koden. Denna ordrikedom, som kan verka onödig i ett enkelt fall, blir en tillgång så snart pipelinen förgrenar sig eller du behöver byta ut en länk utan att röra de andra. Observera också skillnaden mellan MistralDocumentEmbedder och MistralTextEmbedder: den förra kodar dokument vid indexeringstillfället, den senare kommer att koda frågor vid förfrågningstillfället, en separation som förhindrar det klassiska felet att behandla båda på samma sätt.

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

# Indexeringspipeline
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")

Vilket ska du välja?

Varje ramverk har sina styrkor, och tabellen nedan sammanfattar avvägningen.

RamverkHuvudstyrkaOptimalt användningsområde
LangChainRikaste ekosystemet, LangGraph för komplexa kontrollflödenAgenter och avancerad RAG
LlamaIndexEnklast för RAG, native-hantering av strukturerade dokumentSnabb start, nybörjare
HaystackModulär pipeline-approach, stark på utvärderingProduktionsdistribution

Nästa steg

Du har nu alla grunder för att bygga RAG-system med Mistral AI. Du vet hur du kodar text med mistral-embed och dess 1024 dimensioner, kodar kod med codestral-embed och dess konfigurerbara dimensioner upp till 3072, bygger en RAG från grunden på FAISS och Mistral API, och sedan härdar den med korrigerande, självgående och adaptiva arkitekturer. Denna sista lektion lägger till ramverksvägen: LangChain, LlamaIndex och Haystack.

För att gå vidare, utforska de officiella Mistral AI-cookbooks samt notebooks för varje ramverk, som följer API-utvecklingen närmare än någon kurs. RAG är ett snabbt rörande fält: chunking-, retrieval- och verifieringstekniker förbättras ständigt, och det är precis eftersom du har skrivit varje steg för hand som du kommer att kunna utvärdera nästa som dyker upp.

Viktiga punkter

  • LangChain + LangGraph är det främsta valet för avancerade RAG-kontrollflöden
  • LlamaIndex är enklast för standard-RAG med Mistral
  • Haystack excellerar i modularitet och pipeline-utvärdering
  • Alla tre ramverken stöder mistral-embed och mistral-large nativt
  • Börja med RAG från grunden för att förstå, migrera sedan till ett ramverk för produktion

Testa dina kunskaper

Inbäddningar, RAG och avancerade varianter: det stora slutprovet.

1. Vad är Mistrals två inbäddningsmodeller, och vad används de till?

Svar: mistral-embed för generell text, codestral-embed för kod – var och en projicerar sin domän in i ett utrymme där semantisk likhet mäts.

2. Vilka steg ingår i kursens RAG-pipeline?

Svar: Förbered data (chunking), skapa inbäddningar, lagra dem i ett vektorlager (FAISS), sedan retrieval + generering: frågan hittar sina passager, modellen svarar baserat på dem.

3. Vad fixar korrigerande RAG?

Svar: Dåliga retrieval: den utvärderar relevansen hos hämtade passager och utlöser en korrigering (ny sökning, omformulering) innan generering – istället för att svara på brus.

4. Self-RAG och Adaptiv RAG: vad är den gemensamma idén?

Svar: Göra pipelinen reflexiv: besluta när man ska hämta, kritisera sina egna utdata, anpassa strategin till frågan – RAG slutar vara ett fast rör.

5. Vad bidrar LangChain, LlamaIndex eller Haystack med?

Svar: Verktygslåda: färdiga komponenter för inmatning, index, kedjor och utvärdering – användbart för hastighet, förutsatt att du förstår vad de sätter ihop (vilket denna kurs har lärt dig).

Du vet nu hur man bygger en RAG för hand och överlåter den till ett ramverk med full insikt – det är rätt ordning.