Okviri za RAG: LangChain, LlamaIndex, Haystack
Na ovoj stranici
Izvan RAG-a od nule
Izgradio si kompletan RAG pipeline u čistom Pythonu i to je bio ispravan put: sada znaš što radi svaki redak, gdje se kriju pogreške usklađivanja i zašto loše izrezani dio teksta (chunk) uništava odgovor. U produkciji se također možeš osloniti na specijalizirane okvire koji preuzimaju tehničke detalje i dodaju napredne značajke. Tri glavna okvira—LangChain, LlamaIndex i Haystack—svi su kompatibilni s Mistral AI-jem, a izbor između njih ovisi manje o kvaliteti, a više o vrsti aplikacije koju ciljaš.
LangChain s Mistralom
LangChain je najpopularniji okvir za aplikacije temeljene na velikim jezičnim modelima (LLM). Njegova glavna snaga leži u širini ekosustava integracija, nadopunjenog modulom LangGraph za napredne tokove upravljanja. Instalacijski paket uključuje jezgru, konektor za Mistral, integracije zajednice i FAISS.
pip install langchain langchain-mistralai langchain-community faiss-cpu
Minimalni RAG tada staje u tridesetak redaka, a poanta je vidjeti što je nestalo u usporedbi s tvojom ručnom implementacijom. Grupiranje (batching), ponovni pokušaji, konverzija u float32, usklađivanje između vektora i metapodataka: sve to preuzima FAISS.from_texts. RecursiveCharacterTextSplitter zamjenjuje tvoje funkcije za rezanje s istim parametrima kao prije, 1500 znakova i 200 preklapanja. Konačni lanac zapisan je operatorom cijevi (pipe), koji slaže korake slijeva nadesno: retriever dovodi kontekst, RunnablePassthrough prosljeđuje pitanje kakvo jest, prompt ih sastavlja, model generira, a parser izvlači niz znakova.
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
# Mistral modeli
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)
# Rezanje i indeksiranje
splitter = RecursiveCharacterTextSplitter(
chunk_size=1500,
chunk_overlap=200,
)
chunks = splitter.split_text(document_text)
# Stvaranje vektorske pohrane
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# RAG lanac
prompt = ChatPromptTemplate.from_template(
"""Context: {context}
Question: {question}
Answer based on the context."""
)
rag_chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# Upotreba
answer = rag_chain.invoke("How does FAISS work?")
print(answer)
LangGraph za korektivni, samorefleksivni i adaptivni RAG
Gornji linearni lanac radi za standardni RAG, ali ne može stvarati petlje niti grananja—ipak, to je upravo ono što arhitekture iz prethodne tri lekcije rade. LangGraph rješava tu potrebu definiranjem tokova upravljanja kao grafova. Tipizirani GraphState djeluje kao dijeljena memorija: svaki čvor ga prima, čita što mu treba i vraća polja koja ažurira. Prepoznat ćeš svoje vlastite funkcije iza retrieve_node, grade_node i generate_node, pri čemu se grade_document ponovno koristi kakav jest.
Pravi novi mehanizam je add_conditional_edges. Gdje je tvoja Python klasa lančala if naredbe, graf deklarira funkciju odluke—ovdje route_after_grade—i tablicu mogućih odredišta. Ova separacija između poslovne logike čvorova i topologije toka čini pipeline čitljivim na prvi pogled i modificirajućim bez diranja u kod koraka. Jednom kompajliran, graf se poziva kao jednostavna funkcija.
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):
"""Čvor za dohvat."""
question = state["question"]
docs = retriever.get_relevant_documents(question)
return {"documents": docs, "question": question}
def grade_node(state):
"""Čvor za ocjenjivanje dokumenata."""
question = state["question"]
docs = state["documents"]
relevant = []
web_needed = False
for doc in docs:
# Koristi LLM za evaluaciju relevantnosti
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):
"""Čvor za generiranje."""
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):
"""Uvjetna odluka nakon ocjenjivanja."""
if state["web_search_needed"]:
return "web_search"
return "generate"
# Izgradnja grafa
workflow = StateGraph(GraphState)
# Dodavanje čvorova
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)
# Definiranje toka
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)
# Kompajliranje
app = workflow.compile()
# Izvršavanje
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])
LlamaIndex s Mistralom
LlamaIndex gura apstrakciju dalje jer je optimiziran specifično za RAG i upravljanje strukturiranim dokumentima.
pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai
Konfiguracija se odvija putem globalnog objekta Settings koji jednom zauvijek postavlja model za generiranje i model za ugradnju (embedding). SimpleDirectoryReader učitava cijeli direktorij pogađajući formate, a VectorStoreIndex.from_documents lanča rezanje i kodiranje bez potrebe da ih parametriziraš. Dobitak u sažetosti je stvaran, ali izmjeri što to podrazumijeva: strategija rezanja, za koju sada znaš da određuje kvalitetu dohvata, ovdje je odabrana umjesto tebe. Ugodno je za početak, ali to je prva postavka koju ćeš morati ponovno preuzeti u svoje ruke onog dana kada odgovori razočaraju. Imaj na umu da response.source_nodes čuva metapodatke, čime se osigurava sljedivost koju si ručno implementirao.
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
# Globalna konfiguracija
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")
# Učitavanje dokumenata
documents = SimpleDirectoryReader("./data/").load_data()
# Stvaranje indeksa (automatsko rezanje + ugradnja)
index = VectorStoreIndex.from_documents(documents)
# Stvaranje upitnog motora
query_engine = index.as_query_engine(similarity_top_k=3)
# Postavljanje pitanja
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 Mistralom
Haystack, razvijen od strane deepseta, usvaja treću filozofiju: onu modularnih pipelinea, gdje je svaka komponenta imenovana, dodana, a zatim eksplicitno povezana sa svojim susjedima.
pip install haystack-ai mistral-haystack
Donji pipeline za indeksiranje dobro ilustrira ovaj pristup. Deklarirane su tri komponente—rezalica, enkoder putem MistralDocumentEmbedder i pisac u pohranu dokumenata—zatim povezane pozivima connect koji čine tok podataka vidljivim u kodu. Ova opširnost, koja se može činiti nepotrebnom u jednostavnom slučaju, postaje prednost čim se pipeline grana ili trebaš zamijeniti vezu bez diranja ostalih. Također primijeti razliku između MistralDocumentEmbedder i MistralTextEmbedder: prvi kodira dokumente u vrijeme indeksiranja, drugi će kodirati upite u vrijeme ispitivanja, što je separacija koja sprječava klasičnu pogrešku tretiranja oba na isti način.
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
# Pohrana dokumenata
doc_store = InMemoryDocumentStore()
# Pipeline za indeksiranje
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")
Što odabrati
Svaki okvir ima svoje prednosti, a donja tablica sažima kompromise.
| Framework | Glavna prednost | Idealna primjena |
|---|---|---|
| LangChain | Najbogatiji ekosustav, LangGraph za složene tokove upravljanja | Agenti i napredni RAG |
| LlamaIndex | Najjednostavniji za RAG, izvorno rukovanje strukturiranim dokumentima | Brzi početak, početnici |
| Haystack | Modularni pristup pipelineima, snažan u evaluaciji | Implementacija u produkciji |
Sljedeći koraci
Sada imaš sve osnove za izgradnju RAG sustava s Mistral AI-jem. Znaš kako kodirati tekst s mistral-embed i njegovih 1024 dimenzije, kodirati kod s codestral-embed i njegovim podesivim dimenzijama do 3072, izgraditi RAG od nule na FAISS-u i Mistral API-ju, a zatim ga učvrstiti arhitekturama Corrective, Self i Adaptive. Ova završna lekcija dodaje put okvira: LangChain, LlamaIndex i Haystack.
Za daljnji napredak, istraži službene Mistral AI cookbooke kao i bilježnice (notebooks) za svaki okvir, koje prate evoluciju API-ja bliže od bilo kojeg tečaja. RAG je područje koje se brzo mijenja: tehnike rezanja, dohvata i verifikacije stalno se poboljšavaju, a upravo zato što si svaki korak napisao ručno, moći ćeš evaluirati sljedeći koji se pojavi.
Ključne točke
- LangChain + LangGraph primarni je izbor za napredne tokove upravljanja u RAG-u
- LlamaIndex je najjednostavniji za standardni RAG s Mistralom
- Haystack excelsira u modularnosti i evaluaciji pipelinea
- Sva tri okvira izvorno podržavaju mistral-embed i mistral-large
- Započni s RAG-om od nule da bi razumio, zatim migriraj na okvir za produkciju
Provjeri svoje znanje
Ugradnje (embeddings), RAG i napredne varijante: veliki završni ispit.
1. Koji su Mistralova dva modela za ugradnju i čemu služe?
Odgovor: mistral-embed za opći tekst, codestral-embed za kod—svaki projicira svoju domenu u prostor gdje se mjeri semantička sličnost.
2. Koji koraci čine RAG pipeline iz ovog tečaja?
Odgovor: Priprema podataka (rezanje), stvaranje ugradnji, pohrana u vektorsku bazu (FAISS), zatim dohvat + generiranje: pitanje pronalazi svoje odlomke, model odgovara na temelju njih.
3. Što ispravlja Corrective RAG?
Odgovor: Loše dohvate: evaluira relevantnost dohvaćenih odlomaka i pokreće ispravak (nova pretraga, reformulacija) prije generiranja—umjesto odgovaranja na šum.
4. Self-RAG i Adaptive RAG: koja je zajednička ideja?
Odgovor: Učiniti pipeline refleksivnim: odlučiti kada dohvatiti, kritizirati vlastite izlaze, prilagoditi strategiju pitanju—RAG prestaje biti fiksna cijev.
5. Što donose LangChain, LlamaIndex ili Haystack?
Odgovor: Alati: gotove komponente za ingestiju, indekse, lance i evaluaciju—korisno za brzinu, pod uvjetom da razumiješ što sastavljaju (što te ovaj tečaj naučio).
Sada znaš kako izgraditi RAG ručno i povjeriti ga okviru s punom sviješću—to je ispravan redoslijed.