Lähe põhisisu juurde
Eesti— Vali keel
Menüü

RAGi raamistikud: LangChain, LlamaIndex, Haystack

Õppetund 18 / 18 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Rohkem kui RAG nullist
  2. LangChain koos Mistraliga
  3. LlamaIndex koos Mistraliga
  4. Haystack koos Mistraliga
  5. Kumba valida?
  6. Järgmised sammud
  7. Peamised punktid
  8. Testi oma teadmisi

Rohkem kui RAG nullist

Oled ehitanud täieliku RAGi torustiku puhtas Pythonis ja see oli õige tee: nüüd tead, mida iga rida teeb, kus peituvad joondusvead ja miks halvasti tükeldatud plokk vastuse rikub. Toomes saad tugineda ka spetsialiseeritud raamistikele, mis haldavad tehnilist poolt ja lisavad täiustatud funktsioone. Kolm peamist—LangChain, LlamaIndex ja Haystack—ühilduvad kõik Mistral AI-ga ning valik nende vahel sõltub vähem kvaliteedist kui sihitava rakenduse tüübist.

LangChain koos Mistraliga

LangChain on LLM-rakenduste populaarseim raamistik. Selle peamine tugevus on integratsioonide ökosüsteemi laius, mida täiendab täiustatud juhtimisvoogude moodul LangGraph. Paigalduspakett sisaldab tuuma, Mistrali ühendust, kogukonna integratsioone ja FAISS-i.

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

Minimaalne RAG mahub umbes kolmekümnesse ritta ja eesmärk on näha, mis on võrreldes sinu käsitsi tehtud teostusega kadunud. Partiitöö, korduskatsed, teisendamine vormingusse float32, vektorite ja metaandmete joondamine: kõik see neelab ära FAISS.from_texts. RecursiveCharacterTextSplitter asendab sinu tükeldamisfunktsioonid samade parameetritega nagu varem: 1500 märki ja 200 märgine kattumine. Lõplik ahel kirjutatakse toruoperaatoriga, mis komponeerib samme vasakult paremale: otsija (retriever) annab konteksti, RunnablePassthrough edastab küsimuse muutumatuna, viit koondab need, mudel genereerib ja parser eraldab stringi.

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

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

# Tükeldamine ja indekseerimine
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

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

# RAGi ahel
prompt = ChatPromptTemplate.from_template(
    """Context: {context}

Question: {question}

Answer based on the context."""
)

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

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

LangGraph korrigeeriva, enesehindava ja adaptiivse RAGi jaoks

Ülalolev lineaarne ahel töötab standardse RAGi puhul, kuid see ei saa teha silmuseid ega harusid—just seda aga tegid eelmiste kolme tunni arhitektuurid. LangGraph lahendab selle vajaduse, defineerides juhtimisvood graafikutena. Tüübitud GraphState toimib jagatud mäluna: iga sõlm saab selle, loeb vajaliku ja tagastab värskendatavad väljad. Tunned oma funktsioone ära retrieve_node, grade_node ja generate_node taga, kusjuures grade_document on kasutatud muutumatuna.

Tõeliselt uus mehhanism on add_conditional_edges. Kui sinu Pythoni klass kasutas if-lauseid, siis graafik deklareerib otsustusfunktsiooni—siin route_after_grade—ja võimalike sihtkohtade tabeli. See eraldus äritegevuse loogika (sõlmed) ja voo topoloogia vahel muudab torustiku pilguga loetavaks ja muudetavaks ilma sammude koodi puutumata. Kui graafik on kompileeritud, kutsutakse seda nagu lihtsat funktsiooni.

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

def grade_node(state):
    """Dokumentide hindamise sõlm."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Asjakohasuse hindamiseks kasuta LLM-i
        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):
    """Genereerimissõlm."""
    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):
    """Tingimuslik otsus pärast hindamist."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Graafiku ehitamine
workflow = StateGraph(GraphState)

# Sõlmede lisamine
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Voo defineerimine
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)

# Kompileerimine
app = workflow.compile()

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

LlamaIndex koos Mistraliga

LlamaIndex viib abstraktsiooni veelgi kaugemale, kuna see on optimeeritud spetsiaalselt RAGi ja struktureeritud dokumentide haldamiseks.

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

Konfiguratsioon toimub globaalse Settings objekti kaudu, mis seab genereerimismudeli ja manustamismudeli (embedding) üks kord ja lõplikult. SimpleDirectoryReader laadib terve kataloogi, arvates vormingud ise, ja VectorStoreIndex.from_documents aheldab tükeldamise ja kodeerimise ilma, et peaksid neid ise parameetriseerima. Lühidus on reaalne, kuid hinda, mida see tähendab: tükeldamisstrateegia, mis nagu nüüd tead, määrab otsimise kvaliteedi, valitakse siin sinu eest. Alustamiseks on see mugav, kuid see on esimene säte, mille pead uuesti kätte võtma päeval, kui vastused pettumust valmistavad. Pane tähele, et response.source_nodes säilitab metaandmed, seega on tagatud jälgitavus, mille ise käsitsi teostasid.

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

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

# Dokumentide laadimine
documents = SimpleDirectoryReader("./data/").load_data()

# Indeksi loomine (automaatne tükeldamine + manustamine)
index = VectorStoreIndex.from_documents(documents)

# Päringumootori loomine
query_engine = index.as_query_engine(similarity_top_k=3)

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

Haystack koos Mistraliga

Haystack, mille on loonud deepset, võtab omaks kolmanda filosoofia: modulaarsed torustikud, kus iga komponent on nimetatud, lisatud ja seejärel oma naabritega selgesõnaliselt ühendatud.

pip install haystack-ai mistral-haystack

Allpool olev indekseerimistorustik illustreerib seda lähenemist hästi. Deklareeritakse kolm komponenti—tükeldaja, kodeerija läbi MistralDocumentEmbedder ja kirjutaja dokumendihoidlasse—mis seejärel ühendatakse connect-väljakutsetega, muutes andmevoo koodis nähtavaks. See sõnaohtrus, mis lihtsa juhu puhul võib tunduda ebavajalik, muutub varaks niipea, kui torustik haruneb või kui pead asendama ühe lüli teisi puutumata jättes. Pane tähele ka eristust MistralDocumentEmbedder ja MistralTextEmbedder vahel: esimene kodeerib dokumente indekseerimise ajal, teine kodeerib päringuid küsitlemise ajal; see eraldus hoiab ära klassikalise vea, kui mõlemat samamoodi koheldakse.

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

# Dokumendihoidla
doc_store = InMemoryDocumentStore()

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

Kumba valida?

Igal raamistikul on oma tugevused ja allolev tabel võtab kokku kompromissid.

RaamistikPeamine tugevusOptimaalne kasutusala
LangChainRikkalikum ökosüsteem, LangGraph keerukate juhtimisvoogude jaoksAgendid ja täiustatud RAG
LlamaIndexLihtsaim RAGi jaoks, struktureeritud dokumentide loomupärane haldusKiire start, algajad
HaystackModulaarne torustiku lähenemine, tugev hindamisesToomekasutuselevõtt

Järgmised sammud

Nüüd on sul kõik vajalik, et ehitada RAG-süsteeme koos Mistral AI-ga. Tead, kuidas kodeerida teksti mudeliga mistral-embed ja selle 1024 mõõtmega, kodeerida koodi mudeliga codestral-embed ja selle konfigureeritavate mõõtmetega kuni 3072, ehitada RAG nullist FAISS-i ja Mistrali API peale ning seejärel kindlustada seda korrigeeriva, enesehindava ja adaptiivse arhitektuuriga. See viimane tund lisab raamistike tee: LangChain, LlamaIndex ja Haystack.

Süvenemiseks uuri ametlikke Mistral AI kokaraamatuid (cookbooks) ning iga raamistiku märkmikke, mis jälgivad API arengut täpsemalt kui ükski kursus. RAG on kiiresti arenev valdkond: tükeldamise, otsimise ja kontrollimise tehnikad paranevad pidevalt ja just seetõttu, et oled iga sammu ise käsitsi kirjutanud, suudad hinnata järgmist ilmuvat lahendust.

Peamised punktid

  • LangChain + LangGraph on esmane valik täiustatud RAGi juhtimisvoogude jaoks
  • LlamaIndex on lihtsaim standardse RAGi jaoks koos Mistraliga
  • Haystack paistab silma modulaarsuse ja torustike hindamisega
  • Kõik kolm raamistikku toetavad loomupäraselt mudeleid mistral-embed ja mistral-large
  • Alusta RAGiga nullist, et mõista, ja alles siis liigu tootmises raamistiku juurde

Testi oma teadmisi

Manustamised, RAG ja täiustatud variandid: suur lõpueksam.

1. Mis on Mistrali kaks manustamismudelit ja milleks need on?

Vastus: mistral-embed üldteksti jaoks, codestral-embed koodi jaoks—mõlemad projitseerivad oma domeeni ruumi, kus mõõdetakse semantilist sarnasust.

2. Millistest sammudest koosneb kursuse RAGi torustik?

Vastus: Andmete ettevalmistamine (tükeldamine), manustamiste loomine, nende salvestamine vektorpoodi (FAISS), seejärel otsimine + genereerimine: küsimus leiab oma lõigud ja mudel vastab nende põhjal.

3. Mida parandab korrigeeriv RAG?

Vastus: Halbu otsingutulemusi: see hindab leitud lõikude asjakohasust ja käivitab enne genereerimist paranduse (uus otsing, ümberformuleerimine), selle asemel et müra peale vastata.

4. Self-RAG ja Adaptive RAG: mis on nende ühine idee?

Vastus: Muuta torustik refleksseks: otsustada, millal otsida, kritiseerida oma väljundeid, kohandada strateegiat vastavalt küsimusele—RAG lakkab olemast fikseeritud toru.

5. Mida toovad kaasa LangChain, LlamaIndex või Haystack?

Vastus: Tööriistu: valmis komponendid sisestamiseks, indeksite, ahelate ja hindamise jaoks—kasulik kiiruse jaoks, eeldusel et mõistad, mida need kokku panevad (mida see kursus sind on õpetanud).

Nüüd tead, kuidas ehitada RAG käsitsi ja usaldada see raamistikule täieliku teadlikkusega—see on õige järjekord.