Frameworki RAG: LangChain, LlamaIndex, Haystack
Na tej stronie
Poza RAG od podstaw
Zbudowałeś kompletny potok RAG w czystym Pythonie i była to właściwa droga: teraz wiesz, co robi każda linijka, gdzie czają się błędy wyrównania i dlaczego źle pocięty fragment (chunk) rujnuje odpowiedź. W środowisku produkcyjnym możesz jednak polegać na wyspecjalizowanych frameworkach, które zajmują się infrastrukturą i dodają zaawansowane funkcje. Trzy główne z nich – LangChain, LlamaIndex i Haystack – są w pełni kompatybilne z Mistral AI, a wybór między nimi zależy mniej od jakości, a bardziej od typu aplikacji, jaką chcesz stworzyć.
LangChain z Mistral
LangChain to najpopularniejszy framework do aplikacji LLM. Jego główną siłą jest szerokość ekosystemu integracji, uzupełniona o moduł LangGraph do zaawansowanych przepływów sterowania. Instalacja obejmuje rdzeń, konektor Mistral, integracje społecznościowe oraz FAISS.
pip install langchain langchain-mistralai langchain-community faiss-cpu
Minimalny RAG mieści się w około trzydziestu liniach kodu, a celem jest zobaczenie, co zniknęło w porównaniu do Twojej ręcznej implementacji. Batching, ponawianie prób, konwersja do float32, wyrównanie między wektorami a metadanymi – wszystko to jest obsługiwane automatycznie przez FAISS.from_texts. RecursiveCharacterTextSplitter zastępuje Twoje funkcje cięcia tymi samymi parametrami co wcześniej: 1500 znaków i 200 znaków nakładania. Ostateczny łańcuch jest zapisany za pomocą operatora potoku (|), który komponuje kroki od lewej do prawej: retriever dostarcza kontekst, RunnablePassthrough przekazuje pytanie bez zmian, prompt je składa, model generuje odpowiedź, a parser wyciąga ciąg znaków.
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
# Modele Mistral
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)
# Dzielenie i indeksowanie
splitter = RecursiveCharacterTextSplitter(
chunk_size=1500,
chunk_overlap=200,
)
chunks = splitter.split_text(document_text)
# Tworzenie magazynu wektorowego
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# Łańcuch RAG
prompt = ChatPromptTemplate.from_template(
"""Context: {context}
Question: {question}
Answer based on the context."""
)
rag_chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# Użycie
answer = rag_chain.invoke("How does FAISS work?")
print(answer)
LangGraph dla Corrective, Self i Adaptive RAG
Powyższy liniowy łańcuch działa dla standardowego RAG, ale nie potrafi tworzyć pętli ani rozgałęzień – a przecież dokładnie to robiły architektury omawiane w trzech poprzednich lekcjach. LangGraph rozwiązuje ten problem, definiując przepływy sterowania jako grafy. Typowany GraphState działa jako współdzielona pamięć: każdy węzeł otrzymuje go, odczytuje potrzebne dane i zwraca pola, które aktualizuje. Za funkcjami retrieve_node, grade_node i generate_node rozpoznasz swoje własne funkcje, przy czym grade_document jest użyte bez zmian.
Prawdziwie nowym mechanizmem jest add_conditional_edges. Tam, gdzie Twoja klasa w Pythonie używała instrukcji if, graf deklaruje funkcję decyzyjną – tutaj route_after_grade – oraz tabelę możliwych miejsc docelowych. To rozdzielenie logiki biznesowej węzłów od topologii przepływu sprawia, że potok jest czytelny na pierwszy rzut oka i można go modyfikować bez dotykania kodu poszczególnych kroków. Po skompilowaniu graf wywołuje się jak zwykłą funkcję.
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):
"""Węzeł pobierania."""
question = state["question"]
docs = retriever.get_relevant_documents(question)
return {"documents": docs, "question": question}
def grade_node(state):
"""Węzeł oceny dokumentów."""
question = state["question"]
docs = state["documents"]
relevant = []
web_needed = False
for doc in docs:
# Użycie LLM do oceny trafności
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):
"""Węzeł generowania."""
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):
"""Warunkowa decyzja po ocenie."""
if state["web_search_needed"]:
return "web_search"
return "generate"
# Budowa grafu
workflow = StateGraph(GraphState)
# Dodawanie węzłów
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)
# Definicja przepływu
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)
# Kompilacja
app = workflow.compile()
# Wykonanie
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])
LlamaIndex z Mistral
LlamaIndex posuwa abstrakcję jeszcze dalej, ponieważ jest zoptymalizowany specyficznie pod kątem RAG i zarządzania ustrukturyzowanymi dokumentami.
pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai
Konfiguracja odbywa się poprzez globalny obiekt Settings, który ustawia model generujący i model osadzeń raz na zawsze. SimpleDirectoryReader ładuje cały katalog, zgadując formaty plików, a VectorStoreIndex.from_documents łączy cięcie i kodowanie bez konieczności ręcznego parametryzowania tych kroków. Zysk na zwięzłości jest realny, ale musisz zrozumieć, co to oznacza: strategia dzielenia, o której już wiesz, że decyduje o jakości pobierania, jest tutaj wybierana za Ciebie. Jest to wygodne na start, ale będzie to pierwsze ustawienie, do którego będziesz musiał wrócić i przejąć nad nim kontrolę, gdy odpowiedzi zaczną zawodzić. Zauważ, że response.source_nodes zachowuje metadane, co zapewnia śledzalność, którą wcześniej implementowałeś ręcznie.
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
# Konfiguracja globalna
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")
# Ładowanie dokumentów
documents = SimpleDirectoryReader("./data/").load_data()
# Tworzenie indeksu (automatyczne cięcie + osadzanie)
index = VectorStoreIndex.from_documents(documents)
# Tworzenie silnika zapytań
query_engine = index.as_query_engine(similarity_top_k=3)
# Zadawanie pytania
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")
Haystack z Mistral
Haystack, rozwijany przez deepset, przyjmuje trzecią filozofię: modularnych potoków (pipelines), w których każdy komponent jest nazwany, dodany, a następnie jawnie połączony ze swoimi sąsiadami.
pip install haystack-ai mistral-haystack
Poniższy potok indeksowania dobrze ilustruje to podejście. Deklarowane są trzy komponenty – splitter, enkoder poprzez MistralDocumentEmbedder oraz zapis do magazynu dokumentów – a następnie łączone wywołaniami connect, które sprawiają, że przepływ danych jest widoczny w kodzie. Ta gadatliwość, która może wydawać się niepotrzebna w prostym przypadku, staje się atutem, gdy potok się rozgałęzia lub gdy trzeba wymienić jedno ogniwo bez dotykania innych. Zwróć też uwagę na rozróżnienie między MistralDocumentEmbedder a MistralTextEmbedder: pierwszy koduje dokumenty w czasie indeksowania, drugi zakoduje zapytania w czasie odpytywania. To rozdzielenie zapobiega klasycznemu błędowi traktowania obu przypadków w ten sam sposób.
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
# Magazyn dokumentów
doc_store = InMemoryDocumentStore()
# Potok indeksowania
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 wybrać?
Każdy framework ma swoje mocne strony, a poniższa tabela podsumowuje kompromisy.
| Framework | Główna zaleta | Idealne zastosowanie |
|---|---|---|
| LangChain | Najbogatszy ekosystem, LangGraph do złożonych przepływów sterowania | Agenci i zaawansowany RAG |
| LlamaIndex | Najprostszy dla RAG, natywna obsługa ustrukturyzowanych dokumentów | Szybki start, początkujący |
| Haystack | Modularne podejście do potoków, silny w zakresie ewaluacji | Wdrożenia produkcyjne |
Następne kroki
Masz już wszystkie podstawy, aby budować systemy RAG z Mistral AI. Wiesz, jak kodować tekst za pomocą mistral-embed i jego 1024 wymiarów, kodować kod za pomocą codestral-embed z konfigurowalną liczbą wymiarów do 3072, zbudować RAG od podstaw na FAISS i API Mistral, a następnie utwardzić go architekturami Corrective, Self i Adaptive. Ta ostatnia lekcja dodaje ścieżkę frameworków: LangChain, LlamaIndex i Haystack.
Aby pójść dalej, explore oficjalne cookbooks Mistral AI oraz notatniki dla każdego z frameworków, które śledzą ewolucję API dokładniej niż jakikolwiek kurs. RAG to dziedzina, która szybko się rozwija: techniki cięcia, pobierania i weryfikacji ciągle się poprawiają i właśnie dlatego, że napisałeś każdy krok ręcznie, będziesz w stanie ocenić każdą nową metodę, która się pojawi.
Kluczowe wnioski
- LangChain + LangGraph to główny wybór dla zaawansowanych przepływów sterowania w RAG
- LlamaIndex jest najprostszy dla standardowego RAG z Mistral
- Haystack wyróżnia się modularnością i ewaluacją potoków
- Wszystkie trzy frameworki natywnie obsługują mistral-embed i mistral-large
- Zacznij od RAG od podstaw, aby zrozumieć mechanizm, a następnie przejdź do frameworka w celu wdrożenia produkcyjnego
Sprawdź swoją wiedzę
Osadzenia, RAG i zaawansowane warianty: wielki egzamin końcowy.
1. Jakie są dwa modele osadzeń Mistral i do czego służą?
Odpowiedź: mistral-embed do ogólnego tekstu, codestral-embed do kodu – każdy z nich rzutuje swoją domenę na przestrzeń, w której mierzone jest podobieństwo semantyczne.
2. Z jakich kroków składa się potok RAG z tego kursu?
Odpowiedź: Przygotowanie danych (cięcie), tworzenie osadzeń, zapisanie ich w magazynie wektorowym (FAISS), a następnie pobieranie i generowanie: pytanie znajduje odpowiednie fragmenty, a model odpowiada na ich podstawie.
3. Co naprawia Corrective RAG?
Odpowiedź: Słabe wyniki pobierania: ocenia trafność pobranych fragmentów i uruchamia korektę (nowe wyszukiwanie, przeformułowanie) przed generowaniem – zamiast odpowiadać na podstawie szumu.
4. Self-RAG i Adaptive RAG: jaka jest wspólna idea?
Odpowiedź: Uczynienie potoku refleksywnym: decydowanie, kiedy pobierać dane, krytykowanie własnych wyników, dostosowywanie strategii do pytania – RAG przestaje być sztywną rurą.
5. Co wnoszą LangChain, LlamaIndex lub Haystack?
Odpowiedź: Narzędzia: gotowe komponenty do ingestii, indeksów, łańcuchów i ewaluacji – przydatne dla szybkości, pod warunkiem że rozumiesz, co składają (czego nauczył Cię ten kurs).
Teraz wiesz, jak zbudować RAG ręcznie i powierzyć go frameworkowi z pełną świadomością – to właściwa kolejność.