Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Frameworky RAG: LangChain, LlamaIndex, Haystack

Lekcia 18 z 18 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Viac než len RAG od nuly
  2. LangChain s Mistral
  3. LlamaIndex s Mistral
  4. Haystack s Mistral
  5. Čo si vybrať
  6. Ďalšie kroky
  7. Kľúčové poznatky
  8. Otestuj si svoje vedomosti

Viac než len RAG od nuly

Vytvoril si kompletný pipeline RAG v čistom Pythone a bola to správna cesta: teraz vieš, čo robí každý riadok, kde sa skrývajú chyby zarovnania a prečo zle rozdelený chunk zničí odpoveď. V produkcii sa môžeš spoľahnúť aj na špecializované frameworky, ktoré riešia technickú infraštruktúru a pridávajú pokročilé funkcie. Tri hlavné – LangChain, LlamaIndex a Haystack – sú všetky kompatibilné s Mistral AI a výber medzi nimi závisí skôr od typu aplikácie, na ktorú cieliš, než od kvality samotnej.

LangChain s Mistral

LangChain je najpopulárnejší framework pre aplikácie LLM. Jeho hlavnou silou je šírka ekosystému integrácií, doplnená o modul LangGraph pre pokročilé riadenie tokov. Inštalačný balík zahŕňa jadro, konektor pre Mistral, komunitné integrácie a FAISS.

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

Minimálny RAG sa zmestí asi do tridsiatich riadkov a pointou je vidieť, čo oproti tvojej manuálnej implementácii zmizlo. Dávkové spracovanie, opakovanie pokusov, konverzia na float32, zarovnanie medzi vektormi a metadátami: to všetko absorbuje FAISS.from_texts. RecursiveCharacterTextSplitter nahradí tvoje funkcie na rozdelenie textu s rovnakými parametrami ako predtým, 1500 znakov a 200 prekryvov. Finálny reťazec sa zapisuje pomocou operátora potrubia, ktorý skladá kroky zľava doprava: retriever dodá kontext, RunnablePassthrough prenesie otázku tak, ako je, prompt ich poskladá, model vygeneruje odpoveď a parser extrahuje reťazec.

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

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

# Rozdelenie a indexovanie
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Vytvorenie vektorového úložiska
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# Reťazec RAG
prompt = ChatPromptTemplate.from_template(
    """Context: {context}

Question: {question}

Answer based on the context."""
)

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

# Použitie
answer = rag_chain.invoke("How does FAISS work?")
print(answer)

LangGraph pre Corrective, Self a Adaptive RAG

Vyššie uvedený lineárny reťazec funguje pre štandardný RAG, ale nedokáže vytvárať slučky ani vetvenia – práve to však robia architektúry z predchádzajúcich troch lekcií. LangGraph rieši túto potrebu definovaním riadiacich tokov ako grafov. Typovaný GraphState funguje ako zdieľaná pamäť: každý uzol ho prijme, prečíta si, čo potrebuje, a vráti polia, ktoré aktualizuje. Za funkciami retrieve_node, grade_node a generate_node spoznáš svoje vlastné funkcie, pričom grade_document sa použije tak, ako je.

Skutočne novým mechanizmom je add_conditional_edges. Kým tvoja Python trieda spájala príkazy if, graf deklaruje rozhodovaciu funkciu – tu route_after_grade – a tabuľku možných cieľov. Toto oddelenie medzi obchodnou logikou uzlov a topológiou toku robí pipeline čitateľným na prvý pohľad a upraviteľným bez zásahu do kódu jednotlivých krokov. Po skompilovaní sa graf vyvoláva ako jednoduchá funkcia.

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

def grade_node(state):
    """Uzol hodnotenia dokumentov."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Použitie LLM na vyhodnotenie relevance
        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):
    """Uzol generovania."""
    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):
    """Podmienené rozhodnutie po hodnotení."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# zostavenie grafu
workflow = StateGraph(GraphState)

# Pridanie uzlov
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Definovanie toku
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ácia
app = workflow.compile()

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

LlamaIndex s Mistral

LlamaIndex posúva abstrakciu ďalej, pretože je optimalizovaný špecificky pre RAG a štruktúrovanú správu dokumentov.

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

Konfigurácia prebieha cez globálny objekt Settings, ktorý raz a navždy nastaví model pre generovanie a model pre vkladanie (embedding). SimpleDirectoryReader načíta celý adresár odhadnutím formátov a VectorStoreIndex.from_documents zreťazí rozdelenie na chunky a kódovanie bez toho, aby si ich musel parametrizovať. Zisk v stručnosti je reálny, ale zváž, čo to obnáša: stratégia rozdelenia, o ktorej teraz vieš, že určuje kvalitu retrievalu, je tu zvolená za teba. Je to pohodlné pre začiatok, no je to prvé nastavenie, ktoré budeš musieť prevziať späť pod svoju kontrolu v deň, keď ťa odpovede sklamú. Všimni si, že response.source_nodes zachováva metadáta, čím zabezpečuje sledovateľnosť, ktorú si implementoval manuálne.

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álna konfigurácia
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")

# Načítanie dokumentov
documents = SimpleDirectoryReader("./data/").load_data()

# Vytvorenie indexu (automatické rozdelenie + embedding)
index = VectorStoreIndex.from_documents(documents)

# Vytvorenie query engine
query_engine = index.as_query_engine(similarity_top_k=3)

# Položenie otázky
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")

Haystack s Mistral

Haystack, vyvíjaný spoločnosťou deepset, prijíma tretiu filozofiu: modulárne pipeliny, kde je každý komponent pomenovaný, pridaný a následne explicitne prepojený so svojimi susedmi.

pip install haystack-ai mistral-haystack

Nižšie uvedený indexovací pipeline dobre ilustruje tento prístup. Deklarujú sa tri komponenty – rozdeľovač, enkóder cez MistralDocumentEmbedder a zapisovač do úložiska dokumentov – a následne sa prepoja volaniami connect, ktoré robia tok dát v kóde viditeľným. Táto ukecanosť, ktorá sa môže pri jednoduchom prípade zdať zbytočná, sa stáva výhodou hneď, ako sa pipeline vetví alebo potrebuješ vymeniť jeden článok bez dotyku ostatných. Všimni si tiež rozdiel medzi MistralDocumentEmbedder a MistralTextEmbedder: prvý kóduje dokumenty v čase indexovania, druhý bude kódovať dotazy v čase dopytovania, čo je separácia, ktorá zabraňuje klasickej chybe zaobchádzania s oboma rovnakým spôsobom.

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

# Úložisko dokumentov
doc_store = InMemoryDocumentStore()

# Indexovací 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")

Čo si vybrať

Každý framework má svoje silné stránky a nasledujúca tabuľka zhrňuje kompromisy.

FrameworkHlavná silná stránkaIdeálne využitie
LangChainNajbohatší ekosystém, LangGraph pre komplexné riadiace tokyAgenti a pokročilý RAG
LlamaIndexNajjednoduchší pre RAG, natívna práca so štruktúrovanými dokumentmiRýchly štart, začiatočníci
HaystackModulárny prístup k pipelinom, silný v evaluáciiNasadenie do produkcie

Ďalšie kroky

Teraz máš všetky základy na budovanie systémov RAG s Mistral AI. Vieš, ako kódovať text pomocou mistral-embed a jeho 1024 rozmerov, kódovať kód pomocou codestral-embed s jeho nastaviteľnými rozmermi až do 3072, zostaviť RAG od nuly na FAISS a API Mistral a následne ho spevniť architektúrami Corrective, Self a Adaptive. Táto záverečná lekcia pridáva cestu cez frameworky: LangChain, LlamaIndex a Haystack.

Ak chceš ísť ďalej, preskúmaj oficiálne cookbooks Mistral AI, ako aj notebooky pre každý framework, ktoré sledujú vývoj API presnejšie než akýkoľvek kurz. RAG je rýchlo sa vyvíjajúca oblasť: techniky rozdelenia, retrievalu a overovania sa neustále zlepšujú a práve preto, že si každý krok napísal vlastnou rukou, budeš schopný vyhodnotiť ten ďalší, ktorý sa objaví.

Kľúčové poznatky

  • LangChain + LangGraph je primárnou voľbou pre pokročilé riadiace toky RAG
  • LlamaIndex je najjednoduchší pre štandardný RAG s Mistral
  • Haystack vyniká v modularite a evaluácii pipeline
  • Všetky tri frameworky natívne podporujú mistral-embed a mistral-large
  • Začni s RAG od nuly, aby si pochopil podstatu, a až potom prejdite na framework pre produkciu

Otestuj si svoje vedomosti

Embeddingy, RAG a pokročilé varianty: veľká záverečná skúška.

1. Aké sú dva embeddingové modely Mistral a na čo slúžia?

Odpoveď: mistral-embed pre všeobecný text, codestral-embed pre kód – každý premieta svoju doménu do priestoru, kde sa meria sémantická podobnosť.

2. Z akých krokov sa skladá pipeline RAG v tomto kurze?

Odpoveď: Príprava dát (rozdelenie na chunky), vytvorenie embeddingov, ich uloženie do vektorového úložiska (FAISS) a následne retrieval + generovanie: otázka nájde svoje pasáže, model na ich základe odpovie.

3. Čo opravuje Corrective RAG?

Odpoveď: Slabé retrievale: vyhodnocuje relevanciu získaných pasáží a spúšťa opravu (nové vyhľadávanie, preformulovanie) pred generovaním – namiesto odpovedania na šum.

4. Self-RAG a Adaptive RAG: aká je spoločná myšlienka?

Odpoveď: Urobiť pipeline reflexívnym: rozhodovať, kedy retrievovať, kritizovať vlastné výstupy, prispôsobiť stratégiu otázke – RAG prestáva byť fixným potrubím.

5. Čo prinášajú LangChain, LlamaIndex alebo Haystack?

Odpoveď: Nástroje: hotové komponenty pre ingestiu, indexy, reťazce a evaluáciu – užitočné pre rýchlosť, za predpokladu, že rozumieš tomu, čo skladajú (čo ťa tento kurz naučil).

Teraz vieš, ako zostaviť RAG ručne a zveriť ho frameworku s plným uvedomením si – to je správny postup.