Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

RAG-kehykset: LangChain, LlamaIndex, Haystack

Oppitunti 18 / 18 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Muuta kuin RAG tyhjästä
  2. LangChain Mistralilla
  3. LlamaIndex Mistralilla
  4. Haystack Mistralilla
  5. Kumpi valita?
  6. Seuraavat askeleet
  7. Keskeiset asiat
  8. Testaa tietämyksesi

Muuta kuin RAG tyhjästä

Olet rakentanut täydellisen RAG-putken puhtaalla Pythonilla, ja se oli oikea polku: tiedät nyt, mitä jokainen rivi tekee, missä kohdistusvirheet piilevät ja miksi huonosti pilkottu osa tuhoaa vastauksen. Tuotannossa voit kuitenkin luottaa myös erikoistuneisiin kehyksiin, jotka hoitavat perusrakenteet ja tarjoavat edistyneitä ominaisuuksia. Kolme tärkeintä – LangChain, LlamaIndex ja Haystack – ovat kaikki yhteensopivia Mistral AI:n kanssa, ja valinta niiden välillä riippuu vähemmän laadusta kuin kohdistamasi sovellustyypistä.

LangChain Mistralilla

LangChain on suosituin kehys LLM-sovelluksille. Sen suurin vahvuus on integraatioekosysteemin laajuus, jota täydentää LangGraph-moduuli edistyneitä ohjausvirtoja varten. Asennuspaketti sisältää ytimen, Mistral-liittimen, yhteisön integraatiot ja FAISSin.

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

Minimaalinen RAG mahtuu noin kolmeenkymmeneen riviin, ja pointti on nähdä, mitä manuaaliseen toteutukseesi verrattuna on kadonnut. Eräajot, uudelleenyritykset, muunnos muotoon float32, vektoreiden ja metatietojen välinen kohdistus: kaikki tämä imeytyy FAISS.from_texts-funktioon. RecursiveCharacterTextSplitter korvaa pilkkomisfunktiot samoilla parametreilla kuin aiemmin: 1500 merkkiä ja 200 merkin päällekkäisyys. Lopullinen ketju kirjoitetaan putkioperaattorilla, joka yhdistää vaiheet vasemmalta oikealle: hakukone syöttää kontekstin, RunnablePassthrough kierrättää kysymyksen sellaisenaan, kehote kokoaa ne, malli generoi ja jäsennin erottaa merkkijonon.

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-mallit
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)

# Pilkkominen ja indeksointi
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

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

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

Question: {question}

Answer based on the context."""
)

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

# Käyttö
answer = rag_chain.invoke("How does FAISS work?")
print(answer)

LangGraph korjaavaan, itseohjautuvaan ja adaptiiviseen RAG:iin

Yllä oleva lineaarinen ketju toimii standardissa RAG:ssa, mutta se ei voi muodostaa silmukoita tai haarautua – vaikka juuri sitä edellisten kolmen oppitunnin arkkitehtuurit tekivät. LangGraph ratkaisee tämän tarpeen määrittelemällä ohjausvirrat graafeina. Tyypitetty GraphState toimii jaettuna muistina: jokainen solmu vastaanottaa sen, lukee tarvitsemansa ja palauttaa päivitettävät kentät. Tunnistat omat funktiosi kohtien retrieve_node, grade_node ja generate_node takaa, ja grade_document käytetään sellaisenaan.

Todella uusi mekanismi on add_conditional_edges. Siinä missä Python-luokkasi ketjutti if-lauseita, graafi julistaa päätösfunktion – tässä tapauksessa route_after_grade – ja mahdollisten kohteiden taulukon. Tämä erottelu solmujen liiketoimintalogiikan ja virran topologian välillä tekee putkesta silmäiltävissä olevan ja muokattavan koskematta vaiheiden koodiin. Kun graafi on käännetty, sitä kutsutaan kuin yksinkertaista funktiota.

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):
    """Hakusolmu."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Asiakirjojen arviointisolmu."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Käytä LLM:ää relevanssin arviointiin
        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):
    """Generointisolmu."""
    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):
    """Ehdollinen päätös arvioinnin jälkeen."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Rakenna graafi
workflow = StateGraph(GraphState)

# Lisää solmut
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Määritä virta
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)

# Käännä
app = workflow.compile()

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

LlamaIndex Mistralilla

LlamaIndex vie abstraktiota pidemmälle, koska se on optimoitu nimenomaan RAG:lle ja jäsenneltyjen asiakirjojen hallinnalle.

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

Määritys tapahtuu globaalin Settings-objektin kautta, joka asettaa generointimallin ja upotusmallin kerralla lopullisesti. SimpleDirectoryReader lataa koko hakemiston arvaten muodot, ja VectorStoreIndex.from_documents ketjuttaa pilkkomisen ja koodauksen ilman, että sinun tarvitsee parametrisoida niitä. Saavutettu lyhyys on todellinen, mutta mittaa, mitä se merkitsee: pilkkomisstrategia, jonka nyt tiedät määräävän haun laadun, valitaan tässä puolestasi. Se on mukavaa aloittelussa, ja se on ensimmäinen asetus, joka sinun on otettava uudelleen haltuunsi sinä päivänä, kun vastaukset pettävät. Huomaa, että response.source_nodes säilyttää metatiedot, joten manuaalisesti toteuttamasi jäljitettävyys on tallella.

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

# Globaali määritys
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")

# Lataa asiakirjat
documents = SimpleDirectoryReader("./data/").load_data()

# Luo indeksi (automaattinen pilkkominen + upotus)
index = VectorStoreIndex.from_documents(documents)

# Luo kyselymoottori
query_engine = index.as_query_engine(similarity_top_k=3)

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

Haystack Mistralilla

Haystack, jonka on kehittänyt deepset, omaksuu kolmannen filosofian: modulaaristen putkien, joissa jokainen komponentti nimetään, lisätään ja kytketään sitten eksplisiittisesti naapureihinsa.

pip install haystack-ai mistral-haystack

Alla oleva indeksointiputki havainnollistaa tätä lähestymistapaa hyvin. Kolme komponenttia julistetaan – pilkkoja, koodaaja (MistralDocumentEmbedder) ja kirjoittaja asiakirjasäilöön – ja ne yhdistetään connect-kutsuilla, jotka tekevät datan kulusta näkyvää koodissa. Tämä puheliasuus, joka saattaa vaikuttaa tarpeettomalta yksinkertaisessa tapauksessa, muuttuu valtiksi heti, kun putki haarautuu tai kun joudut vaihtamaan linkin koskematta muihin. Huomaa myös ero MistralDocumentEmbedderin ja MistralTextEmbedderin välillä: edellinen koodaa asiakirjat indeksointivaiheessa, jälkimmäinen koodaa kyselyt tiedusteluvaiheessa; tämä erottelu estää klassisen virheen kohdella molempia samalla tavalla.

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

# Asiakirjasäilö
doc_store = InMemoryDocumentStore()

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

Kumpi valita?

Jokaisella kehyksellä on vahvuutensa, ja alla oleva taulukko tiivistää kompromissit.

KehysTärkein vahvuusOptimaalinen käyttökohde
LangChainRikkain ekosysteemi, LangGraph monimutkaisiin ohjausvirtoihinAgentit ja edistynyt RAG
LlamaIndexYksinkertaisin RAG:aan, natiivi tuki jäsennellyille asiakirjoilleNopea aloitus, aloittelijat
HaystackModulaarinen putkilähestymistapa, vahva evaluoinnissaTuotantoon vienti

Seuraavat askeleet

Sinulla on nyt kaikki perustiedot RAG-järjestelmien rakentamiseen Mistral AI:lla. Tiedät, kuinka koodata tekstiä mistral-embedillä ja sen 1024 ulottuvuudella, koodata koodia codestral-embedillä ja sen muokattavilla ulottuvuuksilla aina 3072:een saakka, rakentaa RAG tyhjästä FAISSille ja Mistral API:lle, ja sitten lujittaa sitä korjaavilla, itseohjautuvilla ja adaptiivisilla arkkitehtuureilla. Tämä viimeinen oppitunti lisää kehyksien polun: LangChain, LlamaIndex ja Haystack.

Päästäksesi pidemmälle, tutustu virallisiin Mistral AI -keittokirjoihin sekä kunkin kehyksen notebookeihin, jotka seuraavat API:n kehitystä tarkemmin kuin mikään kurssi. RAG on nopeasti kehittyvä ala: pilkkomis-, haku- ja varmennustekniikat paranevat jatkuvasti, ja juuri siksi, että olet kirjoittanut jokaisen vaiheen käsin, pystyt arvioimaan seuraavan ilmestyvän tekniikan.

Keskeiset asiat

  • LangChain + LangGraph on ensisijainen valinta edistyneisiin RAG-ohjausvirtoihin
  • LlamaIndex on yksinkertaisin standardiin RAG:iin Mistralilla
  • Haystack loistaa modulaarisuudessa ja putkien evaluoinnissa
  • Kaikki kolme kehystä tukevat natiivisti mistral-embediä ja mistral-largea
  • Aloita RAG:lla tyhjästä ymmärtääksesi, siirry sitten kehykseen tuotantoa varten

Testaa tietämyksesi

Upotukset, RAG ja edistyneet variaatiot: suuri loppukoe.

1. Mitkä ovat Mistralin kaksi upotusmallia ja mihin niitä käytetään?

Vastaus: mistral-embed yleiseen tekstiin, codestral-embed koodiin – kumpikin projisoi oman domaininsa avaruuteen, jossa semanttista samankaltaisuutta mitataan.

2. Mistä vaiheista kurssin RAG-putki koostuu?

Vastaus: Valmistele data (pilkominen), luo upotukset, tallenna ne vektoritietokantaan (FAISS), sitten haku + generointi: kysymys löytää kappaleensa, malli vastaa niiden perusteella.

3. Mitä Corrective RAG korjaa?

Vastaus: Huonot haut: se arvioi haettujen kappaleiden relevanssin ja käynnistää korjauksen (uusi haku, uudelleenmuotoilu) ennen generointia – sen sijaan, että vastaisi kohinaan.

4. Self-RAG ja Adaptive RAG: mikä on yhteinen idea?

Vastaus: Tehdä putkesta reflektiivinen: päättää milloin hakea, kritisoida omia tuloksiaan, mukauttaa strategiaa kysymykseen – RAG lakkaa olemasta kiinteä putki.

5. Mitä LangChain, LlamaIndex tai Haystack tuovat mukanaan?

Vastaus: Työkalut: valmiit komponentit ingestioon, indekseihin, ketjuihin ja evaluointiin – hyödyllisiä nopeudelle, edellyttäen että ymmärrät, mitä ne kokoavat (minkä tämä kurssi on opettanut sinulle).

Tiedät nyt, kuinka rakentaa RAG käsin ja uskoa se kehykselle täydessä tietoisuudessa – se on oikea järjestys.