Budowa systemu RAG w Pythonie: LangChain vs LlamaIndex

Wprowadzenie do systemów RAG i roli frameworków

Retrieval-Augmented Generation (RAG) to podejście łączące możliwości dużych modeli językowych (LLM) z zewnętrznymi źródłami wiedzy, takimi jak bazy danych, dokumenty czy zbiory tekstów. Dzięki temu systemy RAG są w stanie generować bardziej trafne, aktualne i uzasadnione odpowiedzi, korzystając z informacji spoza samego modelu językowego.

Tradycyjne modele językowe działają w oparciu o wiedzę wbudowaną w momencie ich trenowania, co sprawia, że mogą nie znać najnowszych informacji lub mieć ograniczony kontekst. RAG rozwiązuje ten problem, integrując mechanizmy wyszukiwania informacji w czasie rzeczywistym. W praktyce oznacza to, że zanim model wygeneruje odpowiedź, najpierw pobiera odpowiednie dane z określonych źródeł, a następnie wykorzystuje je jako kontekst dla generacji.

W kontekście budowy takich systemów, rola frameworków jest kluczowa. Oferują one gotowe komponenty, abstrakcje oraz integracje z narzędziami do przeszukiwania danych, przetwarzania tekstu i komunikacji z LLM. Dzięki nim możliwe jest szybkie prototypowanie, łatwiejsze skalowanie oraz zachowanie przejrzystości kodu.

Na rynku dostępnych jest kilka popularnych frameworków wspierających rozwój systemów RAG. Dwa z nich – LangChain i LlamaIndex – zdobyły szczególne uznanie dzięki swojej elastyczności, modularności i rozbudowanej społeczności. Każdy z nich podchodzi do budowy systemów RAG w nieco inny sposób, oferując różne podejścia do integracji danych, zarządzania przepływem informacji i łączenia komponentów.

Przegląd LangChain: funkcje, architektura i integracje

LangChain to jeden z najpopularniejszych frameworków open-source wykorzystywanych do budowy aplikacji opartych na dużych modelach językowych (LLM), szczególnie w kontekście systemów Retrieval-Augmented Generation (RAG). Jego głównym celem jest ułatwienie integracji modeli językowych z różnorodnymi źródłami danych oraz umożliwienie tworzenia złożonych, modularnych pipeline’ów przetwarzania języka naturalnego. Temat tego artykułu pojawia się w niemal każdej sesji szkoleniowej Cognity – czasem w formie pytania, czasem w formie frustracji.

Funkcje LangChain obejmują szereg narzędzi i komponentów, które wspierają cały proces budowania aplikacji LLM – od ekstrakcji danych, przez zarządzanie kontekstem, po generowanie odpowiedzi. Framework oferuje wsparcie dla łańcuchów przetwarzania danych (tzw. chains), które pozwalają na zestawianie kolejnych etapów działania modelu w sposób przejrzysty i elastyczny. LangChain dostarcza również mechanizmy do obsługi pamięci (memory), które umożliwiają utrzymywanie kontekstu w wieloetapowych interakcjach.

Architektura LangChain opiera się na strukturze modułowej, co pozwala użytkownikom łatwo wymieniać komponenty i dostosowywać je do konkretnych zastosowań. Kluczowe elementy tej architektury to:

• LLM wrappers – umożliwiają integrację z różnymi dostawcami modeli językowych, takimi jak OpenAI, Cohere czy HuggingFace
• Prompt templates – pozwalają na tworzenie dynamicznych zapytań do modeli
• Tools – zewnętrzne narzędzia, które LLM może wykorzystywać do wykonywania zadań, np. wyszukiwania informacji
• Chains – komponenty budujące przepływ logiki w aplikacji
• Agents – bardziej zaawansowane byty, które mogą podejmować decyzje na podstawie wyników działania różnych narzędzi i modeli

Integracje w LangChain są jednym z jego największych atutów. Framework oferuje natywną integrację z wieloma źródłami danych, takimi jak bazy dokumentów (np. Chroma, Weaviate, Pinecone), źródła danych internetowych, API zewnętrzne czy platformy bazodanowe. Dzięki temu możliwe jest łatwe tworzenie systemów RAG, które dynamicznie pobierają informacje z różnych źródeł i wykorzystują je w generowaniu odpowiedzi przez model LLM.

LangChain jest także aktywnie rozwijany przez społeczność i posiada rozbudowaną dokumentację, co czyni go popularnym wyborem wśród inżynierów i badaczy pracujących z technologiami generatywnej AI.

Przegląd LlamaIndex: funkcje, architektura i integracje

LlamaIndex, wcześniej znany jako GPT Index, to framework typu open source zaprojektowany z myślą o efektywnym budowaniu systemów Retrieval-Augmented Generation (RAG). Jego głównym celem jest uproszczenie procesu integracji danych z różnych źródeł z dużymi modelami językowymi (LLM), umożliwiając szybkie tworzenie aplikacji typu question-answering, chatbotów lub systemów rekomendacyjnych z dostępem do zewnętrznych danych.

Kluczowe funkcje LlamaIndex

• Łatwa integracja danych: Obsługuje różnorodne źródła danych, takie jak pliki PDF, bazy danych SQL, strony internetowe, dokumenty Office i wiele innych.
• Indeksowanie kontekstowe: Pozwala na tworzenie inteligentnych struktur indeksów (np. listowych, drzewiastych, wektorowych), które wspierają skuteczniejsze wyszukiwanie informacji.
• Abstrakcja nad pipeline'em RAG: Umożliwia zarządzanie całym przepływem danych – od załadowania źródeł, przez indeksowanie, aż po zapytania i generowanie odpowiedzi – w sposób modularny.
• Obsługa wielu LLM: LlamaIndex może pracować z różnymi modelami, zarówno dostępnymi przez API (np. OpenAI), jak i lokalnymi (np. LLama.cpp, HuggingFace Transformers).

Architektura

Architektura LlamaIndex opiera się na kilku kluczowych komponentach:

• Data Connectors: Moduły służące do ekstrakcji danych z różnych źródeł (np. dokumentów, baz danych, API).
• Index: Struktury indeksujące informacje w różnych formach (np. SimpleListIndex, TreeIndex, VectorStoreIndex), umożliwiające szybkie wyszukiwanie i dopasowanie kontekstu do zapytań.
• Query Engine: Silnik zapytań analizujący pytanie użytkownika i odnajdujący kontekst w danych zindeksowanych.
• Response Synthesizer: Komponent odpowiedzialny za generowanie odpowiedzi przy użyciu LLM na podstawie znalezionego kontekstu.

Przykładowy kod inicjalizacji indeksu

from llama_index import SimpleDirectoryReader, VectorStoreIndex

# Załaduj dokumenty z katalogu
documents = SimpleDirectoryReader("./data").load_data()

# Utwórz indeks wektorowy
index = VectorStoreIndex.from_documents(documents)

# Stwórz silnik zapytań
query_engine = index.as_query_engine()

# Zapytanie użytkownika
response = query_engine.query("Jakie są zalety systemów RAG?")
print(response)

Integracje

LlamaIndex wspiera integrację z wieloma zewnętrznymi narzędziami i bibliotekami, co czyni go elastycznym rozwiązaniem dla szerokiego zakresu projektów:

• Silniki wektorowe: Pinecone, FAISS, Weaviate, Chroma, Qdrant i inne.
• Źródła danych: Google Drive, Notion, Slack, SQL, MongoDB, CSV, PDF, Word itp.
• Modele językowe: OpenAI (GPT-3.5, GPT-4), Anthropic, Cohere, lokalne modele przez HuggingFace i LangChain.

Dużą zaletą LlamaIndex jest jego modularność – każdy komponent można łatwo wymienić lub dostosować, co pozwala na budowę zarówno prostych prototypów, jak i skalowalnych aplikacji produkcyjnych. Jeśli chcesz nauczyć się, jak w praktyce wykorzystać te możliwości, sprawdź Kurs RAG w praktyce - nowoczesne techniki wydobywania i generowania danych.

Porównanie LangChain i LlamaIndex – podobieństwa i różnice

LangChain i LlamaIndex to dwa popularne frameworki wspomagające budowę systemów typu Retrieval-Augmented Generation (RAG). Choć oba dążą do ułatwienia integracji dużych modeli językowych z zewnętrznymi źródłami wiedzy, różnią się podejściem, zakresem funkcji i sposobem integracji komponentów. W Cognity mamy doświadczenie w pracy z zespołami, które wdrażają to rozwiązanie – dzielimy się tym także w artykule.

Podobieństwa

• Oba frameworki wspierają proces tworzenia systemów RAG opartych na dużych modelach językowych (LLM).
• Umożliwiają integrację z popularnymi silnikami wektorowymi (np. FAISS, Pinecone, Chroma) oraz bazami danych.
• Zapewniają funkcje indeksowania, przeszukiwania dokumentów oraz generowania odpowiedzi na podstawie kontekstu.
• Projektowane są z myślą o modularności i łatwej adaptacji do różnych przypadków użycia.

Różnice

Przykładowo, w LangChain można łatwo zbudować agenta wykorzystującego kilka narzędzi do odpowiedzi o różnych źródłach wiedzy:

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

llm = OpenAI()
tools = [Tool(name="Wikipedia", func=search_wikipedia, description="Search Wikipedia")]
agent = initialize_agent(tools, llm, agent="zero-shot-react-description")
response = agent.run("Kim był Nikola Tesla?")

Dla porównania, w LlamaIndex typowy przepływ obejmuje załadowanie dokumentów, stworzenie indeksu i zadanie pytania:

from llama_index import SimpleDirectoryReader, VectorStoreIndex

documents = SimpleDirectoryReader("data/tesla_docs").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("Kim był Nikola Tesla?")

Wybór między tymi rozwiązaniami zależy więc od celu projektu i poziomu kontroli nad jego architekturą. LangChain sprawdzi się lepiej w złożonych aplikacjach z wieloetapową logiką, podczas gdy LlamaIndex oferuje prostsze, ale efektywne narzędzia do pracy z dokumentami i wiedzą domenową.

Kiedy wybrać LangChain, a kiedy LlamaIndex?

Decyzja o wyborze między LangChain a LlamaIndex zależy przede wszystkim od charakterystyki projektu, jego skali, wymagań integracyjnych oraz doświadczenia zespołu z danym frameworkiem. Oba narzędzia wspierają budowę systemów RAG (Retrieval-Augmented Generation), ale różnią się podejściem, zakresem funkcjonalności i elastycznością.

LangChain będzie trafnym wyborem, gdy:

• Potrzebujesz złożonego systemu z wieloetapową logiką i integracją z zewnętrznymi źródłami danych.
• Chcesz budować aplikacje z agentami, pamięcią kontekstową i interfejsem użytkownika.

LlamaIndex sprawdzi się lepiej, gdy:

• Twoim priorytetem jest efektywne indeksowanie dokumentów i szybkie wyszukiwanie informacji.
• Pracujesz z dużymi zbiorami danych i chcesz mieć większą kontrolę nad strukturą zapytań oraz indeksów.

W wielu przypadkach warto rozważyć użycie obu narzędzi równolegle – LlamaIndex do warstwy retrival, a LangChain jako orkiestratora logiki aplikacji. Taka kombinacja pozwala wykorzystać mocne strony każdego z frameworków. Jeśli chcesz lepiej poznać praktyczne zastosowania LangChain i nauczyć się budować własne chatboty RAG, zajrzyj do Kursu LangChain w praktyce – budowa chatbotów, RAG i automatyzacja z AI.

Przykłady kodu: implementacja prostego systemu RAG

System Retrieval-Augmented Generation (RAG) łączy dwa główne komponenty: wyszukiwanie informacji (retrieval) oraz generowanie odpowiedzi (generation) z wykorzystaniem dużych modeli językowych. W Pythonie najczęściej wykorzystywane są do tego frameworki takie jak LangChain i LlamaIndex. Poniżej przedstawiamy uproszczone przykłady implementacji systemu RAG przy użyciu obu tych narzędzi.

Minimalna implementacja RAG w LangChain

LangChain oferuje modularne podejście do budowy aplikacji opartych o LLM, umożliwiając łatwe łączenie komponentów takich jak retrievery, LLM-y czy prompty.

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA

# Inicjalizacja komponentów
embedding = OpenAIEmbeddings()
docsearch = FAISS.from_texts(["Dokument 1", "Dokument 2"], embedding)
retriever = docsearch.as_retriever()
llm = OpenAI()

# Budowa systemu RAG
qa = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)

# Zapytanie
response = qa.run("Co znajduje się w dokumencie 1?")
print(response)

Minimalna implementacja RAG w LlamaIndex

LlamaIndex (dawniej GPT Index) skupia się głównie na zarządzaniu danymi tekstowymi i usprawnieniu procesu budowania indeksów informacji dla LLM-ów.

from llama_index import VectorStoreIndex, SimpleDirectoryReader, ServiceContext
from llama_index.llms import OpenAI

# Wczytanie dokumentów
documents = SimpleDirectoryReader("./dokumenty").load_data()

# Inicjalizacja kontekstu i indeksu
llm = OpenAI()
service_context = ServiceContext.from_defaults(llm=llm)
index = VectorStoreIndex.from_documents(documents, service_context=service_context)

# Tworzenie interfejsu zapytań
query_engine = index.as_query_engine()
response = query_engine.query("O czym jest dokument?")
print(response)

Porównanie podstawowych różnic w implementacji

Oba frameworki umożliwiają stworzenie funkcjonalnego systemu RAG przy minimalnym nakładzie kodu, jednak różnią się podejściem do zarządzania komponentami i integracji z danymi. Wybór odpowiedniego narzędzia zależy m.in. od potrzeb projektowych, złożoności aplikacji i preferencji zespołu.

Testowanie i debugowanie systemów RAG

Systemy Retrieval-Augmented Generation (RAG) łączą komponenty wyszukiwania informacji (retrieval) z modelami generatywnymi, co sprawia, że proces testowania i debugowania wymaga podejścia wielowarstwowego. Błędy mogą wynikać zarówno z niedokładnych wyników wyszukiwania, jak i z nieodpowiednich odpowiedzi generowanych przez model językowy. Aby zapewnić niezawodność i trafność wyników, należy testować każdy komponent osobno, a także analizować ich współdziałanie.

W procesie testowania warto zwrócić uwagę na kilka kluczowych aspektów:

• Ocena jakości retrievera – sprawdzenie, czy system wyszukiwania zwraca najbardziej adekwatne dokumenty względem zapytania użytkownika. Można to przeprowadzać ręcznie (inspekcja wyników) lub automatycznie (np. porównując z wcześniej oznaczonymi danymi).
• Analiza odpowiedzi modelu generatywnego – ocena spójności, zgodności z danymi źródłowymi i kompletności generowanej treści, najlepiej przy wsparciu metryk takich jak factual consistency czy ROUGE.
• Testowanie całościowego przepływu – czyli pełnego pipeline'u od zapytania do wygenerowanej odpowiedzi. Pozwala to wykryć błędy w integracji komponentów lub problemy z przekazywaniem kontekstu między nimi.
• Monitorowanie błędów i logowanie – kluczowe dla debugowania są szczegółowe logi zawierające informacje o zapytaniach, zwróconych dokumentach, promptach oraz odpowiedziach modelu. Pomaga to zidentyfikować, na którym etapie pojawia się problem.
• Testy jednostkowe i integracyjne – automatyczne testy kluczowych funkcji oraz interfejsów między komponentami pomagają wcześnie wykrywać regresje i niepożądane zachowania.

Ważnym elementem debugowania jest także walidacja danych wejściowych – struktura dokumentów, poprawność metadata oraz ich indeksowanie mogą znacząco wpływać na skuteczność retrievalu. W przypadku użycia frameworków takich jak LangChain czy LlamaIndex, warto korzystać z wbudowanych narzędzi do śledzenia przepływu zapytań oraz wizualizacji działania pipeline'u.

Ostatecznie, skuteczne testowanie systemów RAG wymaga zarówno wiedzy technicznej, jak i zrozumienia domeny, w której system jest wykorzystywany. Dzięki temu możliwe jest tworzenie bardziej niezawodnych i użytecznych aplikacji opartych na RAG.

Podsumowanie i rekomendacje

Systemy RAG (Retrieval-Augmented Generation) stanowią istotny krok w rozwoju aplikacji opartych na dużych modelach językowych, umożliwiając im dostęp do zewnętrznych źródeł wiedzy i generowanie bardziej trafnych oraz aktualnych odpowiedzi. Kluczową rolę w budowie takich systemów odgrywają frameworki, które ułatwiają integrację różnych komponentów, takich jak wyszukiwanie dokumentów, zarządzanie kontekstem czy obsługa zapytań użytkowników.

LangChain i LlamaIndex to dwa popularne narzędzia wspierające implementację systemów RAG w Pythonie. Choć oba frameworki mają podobny cel, różnią się podejściem do integracji komponentów oraz zakresem funkcjonalności. LangChain wyróżnia się rozbudowaną strukturą modularną i szeroką gamą integracji z zewnętrznymi narzędziami, co może być zaletą w przypadku bardziej złożonych projektów. Z kolei LlamaIndex (dawniej znany jako GPT Index) koncentruje się na efektywnym zarządzaniu danymi i indeksowaniu wiedzy, co czyni go atrakcyjnym wyborem dla projektów, w których kluczowa jest organizacja i optymalizacja źródeł informacji.

Wybór odpowiedniego frameworka zależy przede wszystkim od potrzeb projektu, skali systemu oraz stopnia zaawansowania zespołu deweloperskiego. Dla prostszych zastosowań, wymagających szybkiego prototypowania, bardziej intuicyjne podejście LlamaIndex może okazać się korzystniejsze. Natomiast w przypadkach, gdy istotna jest elastyczność i możliwość łatwej integracji wielu komponentów, warto rozważyć użycie LangChain. W Cognity łączymy teorię z praktyką – dlatego ten temat rozwijamy także w formie ćwiczeń na szkoleniach.

Skalowanie i optymalizacja RAG w produkcji – koszty, cache, wydajność 04 stycznia 2026

Jak RAG eliminuje halucynacje modeli językowych 02 stycznia 2026