Frameworky RAG: LangChain, LlamaIndex, Haystack
Na této stránce
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.
| Framework | Hlavní síla | Ideální použití |
|---|---|---|
| LangChain | Nejbohatší ekosystém, LangGraph pro složité řídicí toky | Agenti a pokročilé RAG |
| LlamaIndex | Nejjednodušší pro RAG, nativní práce se strukturovanými dokumenty | Rychlý start, začátečníci |
| Haystack | Modulární přístup k pipeline, silný v evaluaci | Nasazení 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í.