Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Frameworky RAG: LangChain, LlamaIndex, Haystack

Lekce 18 z 18 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Víc než jen RAG od nuly
  2. LangChain s Mistral
  3. LlamaIndex s Mistral
  4. Haystack s Mistral
  5. Co si vybrat
  6. Další kroky
  7. Klíčové poznatky
  8. Otestuj své znalosti

Víc než jen RAG od nuly

Postavil jsi kompletní pipeline RAG v čistém Pythonu a byla to správná cesta: teď víš, co dělá každý řádek, kde se schovávají chyby v zarovnání a proč špatně rozdělený chunk zničí odpověď. V produkci se však můžeš spolehnout také na specializované frameworky, které řeší technickou infrastrukturu a přidávají pokročilé funkce. Tři hlavní – LangChain, LlamaIndex a Haystack – jsou všechny kompatibilní s Mistral AI a výběr mezi nimi závisí méně na kvalitě a více na typu aplikace, na kterou cílíš.

LangChain s Mistral

LangChain je nejoblíbenější framework pro aplikace s velkými jazykovými modely (LLM). Jeho hlavní silou je šíře ekosystému integrací, doplněná modulem LangGraph pro pokročilé řízení toků. Instalační balíček zahrnuje jádro, konektor pro Mistral, komunitní integrace a FAISS.

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

Minimální RAG se pak vejde do asi třiceti řádků a jde o to vidět, co oproti tvé manuální implementaci zmizelo. Dávkové zpracování, opakované pokusy, převod na float32, zarovnání mezi vektory a metadaty: to vše pohltí FAISS.from_texts. RecursiveCharacterTextSplitter nahrazuje tvé funkce pro dělení textu se stejnými parametry jako dříve, 1500 znaků a překryv 200. Finální řetězec je zapsán pomocí operátoru pipe, který skládá kroky zleva doprava: retriever dodá kontext, RunnablePassthrough předá otázku tak, jak je, prompt je sestaví, model vygeneruje odpověď a parser extrahuje řetězec.

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)

# Rozdělení a indexování
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Vytvoření vektorového úložiště
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# Řetězec RAG
prompt = ChatPromptTemplate.from_template(
    """Context: {context}

Question: {question}

Answer based on the context."""
)

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

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

LangGraph pro korektivní, vlastní a adaptivní RAG

Výše uvedený lineární řetězec funguje pro standardní RAG, ale neumí se vracet ve smyčkách ani se větvit – přestože přesně to dělají architektury z předchozích tří lekcí. LangGraph řeší tento potřebu definováním řídicích toků jako grafů. Typovaný GraphState funguje jako sdílená paměť: každý uzel jej obdrží, přečte si, co potřebuje, a vrátí pole, která aktualizuje. Za funkcemi retrieve_node, grade_node a generate_node poznáš své vlastní funkce, přičemž grade_document je znovu použito tak, jak je.

Skutečně novým mechanismem je add_conditional_edges. Zatímco tvá Python třída řetězila příkazy if, graf deklaruje rozhodovací funkci – zde route_after_grade – a tabulku možných cílů. Toto oddělení mezi obchodní logikou uzlů a topologií toku činí pipeline na první pohled čitelnou a upravitelnou bez nutnosti zasahovat do kodu jednotlivých kroků. Po zkompilování se graf vyvolá jako jednoduchá funkce.

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):
    """Uzel pro vyhledávání."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Uzel pro hodnocení dokumentů."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Použití LLM k vyhodnocení 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):
    """Generující uzel."""
    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):
    """Podmíněné rozhodnutí po hodnocení."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Sestavení grafu
workflow = StateGraph(GraphState)

# Přidání uzlů
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Definice 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)

# Kompilace
app = workflow.compile()

# Spuštění
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])

LlamaIndex s Mistral

LlamaIndex posouvá abstrakci ještě dál, protože je optimalizován specificky pro RAG a správu strukturovaných dokumentů.

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

Konfigurace probíhá prostřednictvím globálního objektu Settings, který jednou provždy nastaví model pro generování a model pro embeddingy. SimpleDirectoryReader načte celý adresář s odhadem formátů a VectorStoreIndex.from_documents řetězí dělení textu a kódování, aniž bys je musel parametrizovat. Zisk ve stručnosti je reálný, ale změř si, co to obnáší: strategie dělení, o které nyní víš, že určuje kvalitu vyhledávání, je zde zvolena za tebe. Je to pohodlné pro začátek a je to první nastavení, které budeš muset vzít znovu do svých rukou, až tě odpovědi zklamou. Všimni si, že response.source_nodes zachovává metadata, tedy sledovatelnost, kterou jsi implementoval manuálně.

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

# Načtení dokumentů
documents = SimpleDirectoryReader("./data/").load_data()

# Vytvoření indexu (automatické dělení + embeddingy)
index = VectorStoreIndex.from_documents(documents)

# Vytvoření dotazovacího engine
query_engine = index.as_query_engine(similarity_top_k=3)

# Položení 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íjený společností deepset, přijímá třetí filozofii: modulární pipelines, kde je každá komponenta pojmenována, přidána a poté explicitně propojena se svými sousedy.

pip install haystack-ai mistral-haystack

Níže uvedená indexovací pipeline tuto přístup dobře ilustruje. Jsou deklarovány tři komponenty – rozdělovač, enkodér přes MistralDocumentEmbedder a zapisovač do úložiště dokumentů – které jsou poté propojeny voláními connect, díky nimž je tok dat v kódu viditelný. Tato ukecanost, která se může u jednoduchého případu zdát zbytečná, se stává aktivem, jakmile se pipeline větví nebo potřebujete nahradit jeden článek, aniž byste se dotkli ostatních. Všimni si také rozlišení mezi MistralDocumentEmbedder a MistralTextEmbedder: první kóduje dokumenty v době indexování, druhý bude kódovat dotazy v době tázání, což je oddělení, které zabraňuje klasické chybě zacházení s oběma stejně.

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žiště dokumentů
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")

Co si vybrat

Každý framework má své silné stránky a následující tabulka shrnuje kompromisy.

FrameworkHlavní sílaIdeální použití
LangChainNejbohatší ekosystém, LangGraph pro složité řídicí tokyAgenti a pokročilé RAG
LlamaIndexNejjednodušší pro RAG, nativní práce se strukturovanými dokumentyRychlý start, začátečníci
HaystackModulární přístup k pipeline, silný v evaluaciNasazení do produkce

Další kroky

Nyní máš všechny základy pro budování systémů RAG s Mistral AI. Víš, jak kódovat text pomocí mistral-embed a jeho 1024 rozměrů, kódovat kód pomocí codestral-embed s jeho konfigurovatelnými rozměry až do 3072, postavit RAG od nuly na FAISS a API Mistral a poté jej posílit architekturami Corrective, Self a Adaptive. Tato závěrečná lekce přidává cestu přes frameworky: LangChain, LlamaIndex a Haystack.

Aby šel dál, prozkoumej oficiální cookbooks Mistral AI stejně jako notebooky pro každý framework, které sledují vývoj API přesněji než jakýkoli kurz. RAG je rychle se vyvíjející oblast: techniky dělení, vyhledávání a ověřování se neustále zlepšují a právě proto, že jsi každý krok napsal ručně, budeš schopen vyhodnotit ten další, který se objeví.

Klíčové poznatky

  • LangChain + LangGraph je primární volbou pro pokročilé řídicí toky RAG
  • LlamaIndex je nejjednodušší pro standardní RAG s Mistral
  • Haystack vyniká v modularitě a evaluaci pipeline
  • Všechny tři frameworky nativně podporují mistral-embed a mistral-large
  • Začni s RAG od nuly pro pochopení, poté pro produkci migruj na framework

Otestuj své znalosti

Embeddingy, RAG a pokročilé varianty: velká závěrečná zkouška.

1. Jaké jsou dva embeddingové modely Mistral a k čemu slouží?

Odpověď: mistral-embed pro obecný text, codestral-embed pro kód – každý promítá svou doménu do prostoru, kde se měří sémantická podobnost.

2. Z jakých kroků se skládá pipeline RAG v tomto kurzu?

Odpověď: Příprava dat (dělení), vytvoření embeddingů, uložení do vektorového úložiště (FAISS), poté vyhledávání + generování: otázka najde své pasáže, model na jejich základě odpoví.

3. Co opravuje Corrective RAG?

Odpověď: Špatná vyhledávání: hodnotí relevanci získaných pasáží a před generováním spustí opravu (nové hledání, přeformulování) – místo odpovědi na šum.

4. Self-RAG a Adaptive RAG: jaká je společná myšlenka?

Odpověď: Učinit pipeline reflexivní: rozhodovat, kdy vyhledávat, kritizovat vlastní výstupy, přizpůsobovat strategii otázce – RAG přestává být pevnou trubkou.

5. Co přinášejí LangChain, LlamaIndex nebo Haystack?

Odpověď: Nástroje: hotové komponenty pro ingestování, indexy, řetězce a evaluaci – užitečné pro rychlost, za předpokladu, že rozumíš tomu, co sestavují (což tě tento kurz naučil).

Nyní umíš postavit RAG ručně a svěřit ho frameworku s plným vědomím – to je správné pořadí.