Przejdź do głównej treści
Polski— Wybierz język
Menu

Frameworki RAG: LangChain, LlamaIndex, Haystack

Lekcja 18 z 18 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Poza RAG od podstaw
  2. LangChain z Mistral
  3. LlamaIndex z Mistral
  4. Haystack z Mistral
  5. Co wybrać?
  6. Następne kroki
  7. Kluczowe wnioski
  8. Sprawdź swoją wiedzę

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.

FrameworkGłówna zaletaIdealne zastosowanie
LangChainNajbogatszy ekosystem, LangGraph do złożonych przepływów sterowaniaAgenci i zaawansowany RAG
LlamaIndexNajprostszy dla RAG, natywna obsługa ustrukturyzowanych dokumentówSzybki start, początkujący
HaystackModularne podejście do potoków, silny w zakresie ewaluacjiWdroż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ść.