Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

RAG-keretrendszerek: LangChain, LlamaIndex, Haystack

18. lecke 18 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Túl a nulláról épített RAG-on
  2. LangChain Mistrallel
  3. LlamaIndex Mistrallel
  4. Haystack Mistrallel
  5. Melyiket válaszd?
  6. Következő lépések
  7. Főbb megállapítások
  8. Teszteld a tudásod!

Túl a nulláról épített RAG-on

Teljes RAG-folyamatot építettél tiszta Python kóddal, és ez volt a helyes út: most már tudod, mit csinál minden sor, hol bújnak meg az illesztési hibák, és miért ront el egy választást egy rosszul szeletelt chunk. Éles környezetben támaszkodhatsz specializált keretrendszerekre is, amelyek elvégzik a „vízvezeték-szerelést“, és haladó funkciókat adnak hozzá. A három fő szereplő—LangChain, LlamaIndex és Haystack—mind kompatibilis a Mistral AI-val, és a közöttük való választás kevésbé függ a minőségtől, mint inkább a célzott alkalmazás típusától.

LangChain Mistrallel

A LangChain a legnépszerűbb keretrendszer LLM-alkalmazásokhoz. Legfőbb erőssége az integrációs ökoszisztéma szélessége, amelyet a fejlett vezérlési folyamatokhoz készült LangGraph modul egészít ki. A telepítési csomag tartalmazza a magot, a Mistral-csatlakozót, a közösségi integrációkat és a FAISS-t.

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

A minimális RAG ezután kb. harminc sorba fér, és a lényeg annak megfigyelése, mi tűnt el a kézi implementációhoz képest. A kötegelés, az újrapróbálkozások, a float32 konverzió, a vektorok és a metaadatok közötti illesztés: mindezt elnyeli a FAISS.from_texts. A RecursiveCharacterTextSplitter kiváltja a chunkoló függvényeidet ugyanazokkal a paraméterekkel, mint korábban: 1500 karakteres chunkok, 200-as átfedéssel. A végső láncot a pipe operátorral írod meg, amely balról jobbra komponálja a lépéseket: a retriever betölti a kontextust, a RunnablePassthrough változatlanul továbbítja a kérdést, a prompt összeállítja őket, a modell generál, a parser pedig kinyeri a sztringet.

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

# Szeletelés és indexelés
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Vektortár létrehozása
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# RAG lánc
prompt = ChatPromptTemplate.from_template(
    """Context: {context}

Question: {question}

Answer based on the context."""
)

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

# Használat
answer = rag_chain.invoke("How does FAISS work?")
print(answer)

LangGraph korrekciós, önreflexív és adaptív RAG-hoz

A fenti lineáris lánc működik szabványos RAG esetén, de nem képes ciklusokra vagy elágazásokra—pedig pontosan ezt csinálták az előző három leckében bemutatott architektúrák. A LangGraph erre a szükségletre válaszol azzal, hogy vezérlési folyamatokat gráfokként definiál. A típusozott GraphState közös memóriaként működik: minden csomópont megkapja, kiolvassa, amire szüksége van, és visszaadja a frissített mezőket. A retrieve_node, grade_node és generate_node mögött felismered majd a saját függvényeidet, a grade_document pedig változatlanul újrahasznosul.

Az igazán új mechanizmus az add_conditional_edges. Ahol a Python-osztályod if utasításokat láncolt, ott a gráf egy döntési függvényt deklarál—jelen esetben a route_after_grade-et—és a lehetséges célpontok táblázatát. Ez a szétválasztás a csomópontok üzleti logikája és a folyamat topológiája között átláthatóvá teszi a pipeline-t első pillantásra, és lehetővé teszi a módosítást anélkül, hogy hozzá kellene nyúlnod a lépések kódjához. A fordítás után a gráf egyszerű függvényként hívható meg.

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):
    """Lekérési csomópont."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Dokumentum-osztályozó csomópont."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Az LLM használata a relevancia értékelésére
        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):
    """Generáló csomópont."""
    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):
    """Feltételes döntés az osztályozás után."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Gráf felépítése
workflow = StateGraph(GraphState)

# Csomópontok hozzáadása
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Folyamat definiálása
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)

# Fordítás
app = workflow.compile()

# Végrehajtás
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])

LlamaIndex Mistrallel

A LlamaIndex tovább viszi az absztrakciót, mivel kifejezetten RAG-ra és strukturált dokumentumkezelésre optimalizálták.

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

A konfiguráció egy globális Settings objektumon keresztül történik, amely egyszer és mindenkorra beállítja a generáló modellt és a beágyazási modellt. A SimpleDirectoryReader betölt egy teljes könyvtárat a formátumok automatikus felismerésével, a VectorStoreIndex.from_documents pedig láncolja a chunkolást és a kódolást anélkül, hogy neked paraméterezned kellene őket. A tömörség nyeresége valós, de mérd fel, mit jelent ez: a szeletelési stratégiát, amelyről most már tudod, hogy meghatározza a lekérdezés minőségét, itt helyetted választják meg. Kényelmes a kezdéshez, és ez lesz az első beállítás, amit újra kézbe kell venned, ha a válaszok csalódást keltenek. Figyeld meg, hogy a response.source_nodes megőrzi a metaadatokat, így biztosítva azt a nyomon követhetőséget, amit kézzel implementáltál.

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

# Globális konfiguráció
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")

# Dokumentumok betöltése
documents = SimpleDirectoryReader("./data/").load_data()

# Index létrehozása (automatikus chunkolás + beágyazás)
index = VectorStoreIndex.from_documents(documents)

# Lekérdező motor létrehozása
query_engine = index.as_query_engine(similarity_top_k=3)

# Kérdés feltevése
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")

Haystack Mistrallel

A Haystack, amelyet a deepset fejlesztett, egy harmadik filozófiát követ: a moduláris pipeline-okét, ahol minden komponenst elnevezünk, hozzáadunk, majd explicit módon összekötünk a szomszédaival.

pip install haystack-ai mistral-haystack

Az alábbi indexelő pipeline jól illusztrálja ezt a megközelítést. Három komponenst deklarálunk—a szeletelőt, a kódolót a MistralDocumentEmbedder segítségével és az írót a dokumentumtárba—majd connect hívásokkal láncoljuk össze őket, ami láthatóvá teszi az adatfolyamot a kódban. Ez a bőség, amely egyszerű esetben feleslegesnek tűnhet, előnnyé válik, amint a pipeline elágazik, vagy ki kell cserélni egy láncszemet anélkül, hogy a többihez hozzá kellene nyúlni. Figyeld meg továbbá a különbséget a MistralDocumentEmbedder és a MistralTextEmbedder között: az előbbi dokumentumokat kódol indexeléskor, az utóbbi pedig lekérdezéskor kódolja a kérdéseket; ez a szétválasztás megelőzi azt a klasszikus hibát, amikor mindkettőt ugyanúgy kezeljük.

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

# Dokumentumtár
doc_store = InMemoryDocumentStore()

# Indexelő pipeline
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")

Melyiket válaszd?

Minden keretrendszernek megvannak az erősségei, az alábbi táblázat pedig összefoglalja a kompromisszumokat.

KeretrendszerFő erősségIdeális alkalmazási terület
LangChainLeggazdagabb ökoszisztéma, LangGraph a komplex vezérlési folyamatokhozÁgensek és haladó RAG
LlamaIndexLegegyszerűbb RAG-hoz, natív kezelés strukturált dokumentumokhozGyors kezdés, kezdőknek
HaystackModuláris pipeline-megközelítés, erős az értékelésbenÉles környezeti telepítés

Következő lépések

Most már megvan minden alapod ahhoz, hogy RAG-rendszereket építs Mistral AI-val. Tudod, hogyan kódolj szöveget a mistral-embeddel és annak 1024 dimenziójával, hogyan kódolj kódot a codestral-embeddel és annak 3072-ig konfigurálható dimenzióival, hogyan építs RAG-t nulláról FAISS-ra és a Mistral API-ra, majd hogyan tedd robosztussá korrekciós, önreflexív és adaptív architektúrákkal. Ez az utolsó lecke hozzáadja a keretrendszer-utat: LangChain, LlamaIndex és Haystack.

A továbblépéshez fedezd fel a hivatalos Mistral AI szakácskönyveket (cookbooks), valamint az egyes keretrendszerek notebookjait, amelyek szorosabban követik az API fejlődését, mint bármely tanfolyam. A RAG gyorsan fejlődő terület: a chunkolási, lekérdezési és ellenőrzési technikák folyamatosan javulnak, és éppen azért, mert minden lépést kézzel írtál meg, lesz képesed felmérni a következőt, ami megjelenik.

Főbb megállapítások

  • A LangChain + LangGraph az elsődleges választás haladó RAG vezérlési folyamatokhoz
  • A LlamaIndex a legegyszerűbb szabványos RAG-hoz Mistrallel
  • A Haystack a modularitásban és a pipeline-értékelésben jeleskedik
  • Mindhárom keretrendszer natívan támogatja a mistral-embedet és a mistral-large-ot
  • Kezdd a nulláról épített RAG-gal a megértéshez, majd migrálj keretrendszerre éles környezetben

Teszteld a tudásod!

Beágyazások, RAG és haladó variánsok: a nagy záróvizsga.

1. Mi a Mistral két beágyazási modellje, és mire valók?

Válasz: A mistral-embed az általános szövegnek, a codestral-embed a kódnak szól—mindkettő saját domainjét vetíti ki egy olyan térbe, ahol a szemantikai hasonlóság mérhető.

2. Milyen lépésekből áll a tanfolyam RAG-folyamata?

Válasz: Adatelőkészítés (chunkolás), beágyazások létrehozása, tárolásuk egy vektortárban (FAISS), majd lekérdezés + generálás: a kérdés megtalálja a megfelelő passage-okat, a modell pedig ezek alapján válaszol.

3. Mit javít a Korrekciós RAG?

Válasz: A gyenge lekérdezéseket: értékeli a lekért passage-ok relevanciáját, és generálás előtt korrekciót indít el (új keresés, átfogalmazás)—ahelyett, hogy zajra válaszolna.

4. Önreflexív RAG és Adaptív RAG: mi a közös gondolat?

Válasz: A pipeline reflexívvé tétele: eldönteni, mikor kell lekérdezni, kritikusan szemlélni a saját kimeneteket, a stratégiát a kérdéshez igazítani—a RAG megszűnik fix csővezeték lenni.

5. Mit hoznak a LangChain, a LlamaIndex vagy a Haystack?

Válasz: Eszközöket: kész komponenseket a betápláláshoz, indexekhez, láncokhoz és értékeléshez—hasznos a sebesség érdekében, feltéve, hogy érted, mit szerelnek össze (amit ez a tanfolyam megtanított neked).

Most már tudod, hogyan építs RAG-t kézzel, és hogyan bízd azt keretrendszerre teljes tudatossággal—ez a helyes sorrend.