Okvirji RAG: LangChain, LlamaIndex, Haystack
Na tej strani
Poleg RAG od ničle
Zgradil si celoten cevovod RAG v čistem Pythonu in to je bila prava pot: zdaj veš, kaj počne vsaka vrstica, kje se skrivajo napake pri usklajevanju in zakaj slabo razrezan kos uniči odgovor. V proizvodnem okolju se lahko zanašaš tudi na specializirane okvire, ki prevzamejo tehnično infrastrukturo in dodajo napredne funkcije. Trije glavni—LangChain, LlamaIndex in Haystack—so vsi združljivi z Mistral AI, izbira med njimi pa je manj odvisna od kakovosti kot od vrste aplikacije, ki jo ciljaš.
LangChain z Mistralom
LangChain je najbolj priljubljen okvir za aplikacije z velikimi jezikovnimi modeli (LLM). Njegova glavna prednost je širina ekosistema integracij, ki ga dopolnjuje modul LangGraph za napredne nadzorne tokove. Namestitveni paket vključuje jedro, konektor za Mistral, integracije skupnosti in FAISS.
pip install langchain langchain-mistralai langchain-community faiss-cpu
Minimalni RAG se nato prilega v približno trideset vrstic, bistvo pa je videti, kaj je izginilo v primerjavi s tvojo ročno implementacijo. Paketno obdelavo, ponovne poskuse, pretvorbo v float32, usklajevanje med vektorji in metapodatki: vse to prevzame FAISS.from_texts. RecursiveCharacterTextSplitter nadomesti tvoje funkcije za razrezanje z enakimi parametri kot prej, 1500 znakov in 200 prekrivanja. Končni verig je zapisana z operatorjem cevi, ki sestavlja korake od leve proti desni: iskalnik napaja kontekst, RunnablePassthrough kroži vprašanje takšno, kot je, poziv jih sestavi, model generira in parser izvleče niz.
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)
# Razrezanje in indeksiranje
splitter = RecursiveCharacterTextSplitter(
chunk_size=1500,
chunk_overlap=200,
)
chunks = splitter.split_text(document_text)
# Ustvari vektorsko shrambo
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# RAG veriga
prompt = ChatPromptTemplate.from_template(
"""Context: {context}
Question: {question}
Answer based on the context."""
)
rag_chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# Uporaba
answer = rag_chain.invoke("How does FAISS work?")
print(answer)
LangGraph za korektivni, samorefleksivni in prilagodljivi RAG
Zgornja linearna veriga deluje za standardni RAG, vendar ne more ustvarjati zank ali vej—prav to pa počnejo arhitekture iz prejšnjih treh lekcij. LangGraph naslavlja to potrebo z definicijo nadzornih tokov kot grafov. Tipiziran GraphState deluje kot skupni pomnilnik: vsako vozlišče ga prejme, prebere, kar potrebuje, in vrne polja, ki jih posodobi. Za svojimi funkcijami boš prepoznal retrieve_node, grade_node in generate_node, pri čemer je grade_document ponovno uporabljen takšen, kot je.
Resnično nov mehanizem je add_conditional_edges. Kjer si v razredu Python uporabljal zaporedne stavke if, graf deklariira odločitveno funkcijo—tukaj route_after_grade—in tabelo možnih destinacij. Ta ločitev med poslovno logiko vozlišč in topologijo toka naredi cevovod berljiv na prvi pogled in ga omogoča spreminjati brez dotikanja kode korakov. Ko je graf kompiliran, se ga prikliče kot preprosto funkcijo.
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):
"""Vozlišče za pridobivanje."""
question = state["question"]
docs = retriever.get_relevant_documents(question)
return {"documents": docs, "question": question}
def grade_node(state):
"""Vozlišče za ocenjevanje dokumentov."""
question = state["question"]
docs = state["documents"]
relevant = []
web_needed = False
for doc in docs:
# Uporabi LLM za oceno ustreznosti
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):
"""Vozlišče 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):
"""Pogojna odločitev po ocenjevanju."""
if state["web_search_needed"]:
return "web_search"
return "generate"
# Zgradi graf
workflow = StateGraph(GraphState)
# Dodaj vozlišča
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)
# Definiraj tok
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)
# Kompiliraj
app = workflow.compile()
# Izvedi
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])
LlamaIndex z Mistralom
LlamaIndex potiska abstrakcijo dlje, saj je optimiziran specifično za RAG in upravljanje strukturiranih dokumentov.
pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai
Konfiguracija poteka prek globalnega objekta Settings, ki enkrat za vselej nastavi model za generiranje in model za vdelave. SimpleDirectoryReader naloži celoten imenik z ugibanjem formatov, VectorStoreIndex.from_documents pa veriži razrezanje in kodiranje, ne da bi jih moral parametrizirati. Dobiček v jedrnatosti je resničen, a izmeri, kaj to pomeni: strategija razrezanja, za katero zdaj veš, da določa kakovost pridobivanja, je tu izbrana namesto tebe. Priročna je za začetek, vendar bo to prva nastavitev, ki jo boš moral prevzeti nazaj v svoje roke, ko bodo odgovori razočarali. Upoštevaj, da response.source_nodes ohranja metapodatke, torej sledljivost, ki si jo implementiral ročno.
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")
# Naloži dokumente
documents = SimpleDirectoryReader("./data/").load_data()
# Ustvari indeks (samodejno razrezanje + vdelave)
index = VectorStoreIndex.from_documents(documents)
# Ustvari poizvedbeni pogon
query_engine = index.as_query_engine(similarity_top_k=3)
# Postavi vprašanje
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 Mistralom
Haystack, ki ga je razvil deepset, sprejema tretjo filozofijo: tisto modularnih cevovodov, kjer je vsaka komponenta poimenovana, dodana in nato eksplicitno povezana s svojimi sosedi.
pip install haystack-ai mistral-haystack
Spodnji cevovod za indeksiranje dobro ponazarja ta pristop. Deklarirane so tri komponente—razcepljevalnik, kodirnik prek MistralDocumentEmbedder in zapisovalnik v shrambo dokumentov—nato pa povezane s klici connect, ki v kodi naredijo pretok podatkov viden. Ta многословnost, ki se morda zdi nepotrebna pri preprostem primeru, postane sredstvo, ko se cevovod razveja ali ko moraš zamenjati povezavo, ne da bi se dotaknil drugih. Prav tako opazi razliko med MistralDocumentEmbedder in MistralTextEmbedder: prvi kodira dokumente ob času indeksiranja, drugi pa bo kodiral poizvedbe ob času spraševanja, ločitev, ki preprečuje klasično napako obravnave obeh na enak 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
# Shramba dokumentov
doc_store = InMemoryDocumentStore()
# Cevovod 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")
Katerega izbrati
Vsak okvir ima svoje prednosti, spodnja tabela pa povzema kompromise.
| Okvir | Glavna prednost | Idealna uporaba |
|---|---|---|
| LangChain | Najbogatejši ekosistem, LangGraph za kompleksne nadzorne tokove | Agenti in napredni RAG |
| LlamaIndex | Najpreprostejši za RAG, izvorno upravljanje strukturiranih dokumentov | Hiter začetek, začetniki |
| Haystack | Modularni pristop s cevovodi, močan pri evalvaciji | Razporeditev v proizvodnjo |
Naslednji koraki
Zdaj imaš vse osnove za gradnjo sistemov RAG z Mistral AI. Veš, kako kodirati besedilo z mistral-embed in njegovimi 1024 dimenzijami, kodirati kodo s codestral-embed in njegovimi konfigurabilnimi dimenzijami do 3072, zgraditi RAG od nič na FAISS in API-ju Mistral, nato pa ga utrditi s korektivnimi, samorefleksivnimi in prilagodljivimi arhitekturami. Ta zadnja lekcija dodaja pot okvirjev: LangChain, LlamaIndex in Haystack.
Za nadaljnje raziskovanje si oglej uradne kuharske knjige (cookbooks) Mistral AI ter zvezke (notebooks) za vsak okvir, ki natančneje sledijo razvoju API-ja kot kateri koli tečaj. RAG je hitro gibljivo področje: tehnike razrezanja, pridobivanja in preverjanja se nenehno izboljšujejo, in prav zato, ker si vsak korak napisal ročno, boš lahko ovrednotil naslednjega, ki se bo pojavil.
Ključne ugotovitve
- LangChain + LangGraph je primarna izbira za napredne nadzorne tokove RAG
- LlamaIndex je najpreprostejši za standardni RAG z Mistralom
- Haystack odličuje v modularnosti in evalvaciji cevovodov
- Vsi trije okvirji izvorno podpirajo mistral-embed in mistral-large
- Začni z RAG od ničle za razumevanje, nato pa za proizvodnjo migriraj na okvir
Preveri svoje znanje
Vdelave, RAG in napredne različice: veliki zaključni izpit.
1. Katera sta dva Mistralova modela za vdelave in čemu služita?
Odgovor: mistral-embed za splošno besedilo, codestral-embed za kodo—vsak projicira svojo domeno v prostor, kjer se meri semantična podobnost.
2. Kateri koraki sestavljajo cevovod RAG tega tečaja?
Odgovor: Priprava podatkov (razrezanje), ustvarjanje vdelav, njihovo shranjevanje v vektorsko shrambo (FAISS), nato pridobivanje + generiranje: vprašanje najde svoje odlomke, model odgovori na njihovi podlagi.
3. Kaj popravi korektivni RAG?
Odgovor: Slaba pridobivanja: oceni ustreznost pridobljenih odlomkov in sproži popravek (novo iskanje, preoblikovanje) pred generiranjem—namesto odgovarjanja na šum.
4. Self-RAG in Adaptive RAG: kaj je skupna ideja?
Odgovor: Cevovod narediti refleksiven: odločiti se, kdaj pridobivati, kritizirati lastne izhode, prilagoditi strategijo vprašanju—RAG preneha biti fiksna cev.
5. Kaj prinašajo LangChain, LlamaIndex ali Haystack?
Odgovor: Orodja: pripravljene komponente za vnos, indekse, verige in evalvacijo—uporabno za hitrost, pod pogojem, da razumeš, kaj sestavljajo (kar te je naučil ta tečaj).
Zdaj znaš zgraditi RAG ročno in ga z polno zavestjo prepustiti okvirju—to je pravilen vrstni red.