Qafas RAG: LangChain, LlamaIndex, Haystack
F'din il-paġna
Lil hinn minn RAG mill-bidu
Bnejt pipeline RAG sħiħ f’Python pur, u dik kienet it-triq it-tajba: issa taf x’tagħmel kull linja, fejn jinstabu l-iżbalji ta’ allinjament, u għaliex biċċa (chunk) maqtugħa ħażin teħdem it-tweġiba. Fil-produzzjoni, tista’ tiddependi wkoll fuq qafas speċjalizzati li jittrattaw l-infrastruttura teknika u jżidu karatteristiċi avvanzati. It-tlieta ewlenin—LangChain, LlamaIndex, u Haystack—huma kollha kompatibbli ma’ Mistral AI, u l-għażla bejniethom tiddependi inqas fuq il-kwalità u aktar fuq it-tip ta’ applikazzjoni li qed timmira lejha.
LangChain ma’ Mistral
LangChain huwa l-aktar qafas popolari għal applikazzjonijiet LLM. Is-saħħa prinċipali tiegħu hija l-wisa’ tal-ekosistema ta’ integrazzjoni tiegħu, ikkomplementata mill-modulu LangGraph għal flussi ta’ kontroll avvanzati. L-installazione tiġbor fiha l-qalba, il-konnettur ta’ Mistral, integrazzjonijiet tal-komunità, u FAISS.
pip install langchain langchain-mistralai langchain-community faiss-cpu
Ir-RAG minimu mbagħad joqgħod f’madwar tletin linja, u l-punt huwa li tara x’għeb meta mqabbel mal-implimentazzjoni manwali tiegħek. Il-batching, it-tentattivi mill-ġdid (retries), il-konverżjoni għal float32, l-allinjament bejn il-vetturi u l-metadejta: dan kollu jiġi assorbit minn FAISS.from_texts. Ir-RecursiveCharacterTextSplitter jieħu post il-funzjonijiet tal-qsim tiegħek bl-istess parametri bħal qabel, 1500 karattru u 200 ta’ sovrappożizzjoni. Il-katina finali hija miktuba bl-operatur tal-pajp, li jikkombina l-passi mix-xellug għal-lemin: ir-retriever jipprovdi l-kuntest, RunnablePassthrough iċirkola l-mistoqsija kif inhi, il-prompt jgħaqqadhom, il-mudell jiġġenera, u l-parser jestraċi l-korda.
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
# Mudelli ta' Mistral
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)
# Qsim u indicizzar
splitter = RecursiveCharacterTextSplitter(
chunk_size=1500,
chunk_overlap=200,
)
chunks = splitter.split_text(document_text)
# Oħloq il-ħażna tal-vetturi
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# Katina RAG
prompt = ChatPromptTemplate.from_template(
"""Context: {context}
Question: {question}
Answer based on the context."""
)
rag_chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# Użu
answer = rag_chain.invoke("How does FAISS work?")
print(answer)
LangGraph għal RAG Korrettiv, Awto, u Adattattiv
Il-katina lineari ta’ hawn fuq taħdem għal RAG standard, iżda ma tistax tagħmel loop jew fergħat—madankollu, dan huwa eżattament dak li jagħmlu l-arkitetturi fit-tliet lezzjonijiet preċedenti. LangGraph jindirizza din il-ħtieġa billi jiddefinixxi flussi ta’ kontroll bħala grafi. Il-GraphState ittajpjat jaġixxi bħala memorja kondiviża: kull node jirċieviha, jaqra dak li għandu bżonn, u jirritorna l-oqsma li jaġġorna. Se tirrikonoxxi l-funzjonijiet tiegħek stess wara retrieve_node, grade_node, u generate_node, b’grade_document użata kif inhi.
Il-mekkaniżmu verament ġdid huwa add_conditional_edges. Fejn il-klassi Python tiegħek kienet tgħaqqad stqarrijiet if, il-grafu jiddikjara funzjoni ta’ deċiżjoni—hawnhekk route_after_grade—u t-tabella tad-destinazzjonijiet possibbli. Din is-separazzjoni bejn il-loġika tan-negozju tan-nodes u t-topoloġija tal-fluss tagħmel il-pipeline leġibbli f’daqqa waħda u modifikabbli mingħajr ma tmiss il-kodiċi tal-pass. Ladarba kkumpilat, il-grafu jiġi invokat bħala funzjoni sempliċi.
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):
"""Node ta' rkupru."""
question = state["question"]
docs = retriever.get_relevant_documents(question)
return {"documents": docs, "question": question}
def grade_node(state):
"""Node ta' evalwazzjoni tad-dokumenti."""
question = state["question"]
docs = state["documents"]
relevant = []
web_needed = False
for doc in docs:
# Uża l-LLM biex tevalwa r-rilevanza
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):
"""Node ta' ġenerazzjoni."""
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):
"""Deċiżjoni kondizzjonali wara l-evalwazzjoni."""
if state["web_search_needed"]:
return "web_search"
return "generate"
# Ibni l-grafu
workflow = StateGraph(GraphState)
# Żid in-nodes
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)
# Iddefinixxi l-fluss
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)
# Ikkompila
app = workflow.compile()
# Eżegwixxi
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])
LlamaIndex ma’ Mistral
LlamaIndex timbotta l-astrazzjoni aktar ‘il quddiem għax hija ottimizzata speċifikament għal RAG u ġestjoni strutturata tad-dokumenti.
pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai
Il-konfigurazzjoni sseħħ permezz ta’ oġġett globali Settings li jistabbilixxi l-mudell ta’ ġenerazzjoni u l-mudell ta’ embedding darba għal dejjem. SimpleDirectoryReader ittagħbja direttorju sħiħ billi jissuspetta l-formati, u VectorStoreIndex.from_documents tgħaqqad il-qsim u l-encoding mingħajr ma jkollok bżonn tipparametrizzahom. Il-gwadanja fil-konċiżjoni hija reali, iżda kejjel x’timplika: l-istrateġija tal-qsim, li issa taf li tiddetermina l-kwalità tal-irkupru, hija magħżula għalik hawnhekk. Hija komda biex tibda, u hija l-ewwel setting li jkollok terġa’ tieħu f’idejk il-jum li t-tweġibiet jiddeludu. Innota li response.source_nodes iżżomm il-metadejta, għalhekk it-traċċabbiltà li implimentajt manwalment.
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
# Konfigurazzjoni globali
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")
# Ittagħbja d-dokumenti
documents = SimpleDirectoryReader("./data/").load_data()
# Oħloq l-indiċi (qsim awtomatiku + embedding)
index = VectorStoreIndex.from_documents(documents)
# Oħloq l-engine tal-mistoqsijiet
query_engine = index.as_query_engine(similarity_top_k=3)
# Agħmel mistoqsija
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")
Haystack ma’ Mistral
Haystack, żviluppat minn deepset, jadotta filosofija t-tielet: dik ta’ pipelines modulari, fejn kull komponent huwa msemmi, miżjud, u mbagħad imqabbad b’mod espliċitu mal-ġirien tiegħu.
pip install haystack-ai mistral-haystack
Il-pipeline ta’ indicizzar hawn taħt juri dan l-approċċ sewwa. Tliet komponenti huma ddikjarati—id-diviżur, l-encoder permezz ta’ MistralDocumentEmbedder, u l-kittieb fil-ħażna tad-dokumenti—imbagħad imqabbda permezz ta’ sejħiet connect li jagħmlu l-fluss tad-data viżibbli fil-kodiċi. Din il-verbosità, li tista’ tidher mhux meħtieġa f’każ sempliċi, issir assi hekk kif il-pipeline jifferenzja jew ikollok bżonn tibdel rabta mingħajr ma tmiss l-oħrajn. Innota wkoll id-distinzjoni bejn MistralDocumentEmbedder u MistralTextEmbedder: l-ewwel wieħed jikkodifika d-dokumenti fil-ħin tal-indiċizzar, it-tieni wieħed se jikkodifika l-mistoqsijiet fil-ħin tal-interrogazzjoni, separazzjoni li tipprevjeni l-iżball klassiku li tittratta t-tnejn bl-istess mod.
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
# Ħażna tad-dokumenti
doc_store = InMemoryDocumentStore()
# Pipeline ta' indicizzar
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")
Liema wieħed tagħżel?
Kull qafas għandu l-punti qawwija tiegħu, u t-tabella hawn taħt tgħaqqad il-kompromess.
| Framework | Saħħa Prinċipali | L-Aħjar Użu |
|---|---|---|
| LangChain | L-aktar ekosistema rikka, LangGraph għal flussi ta’ kontroll kumplessi | Aġenti u RAG avvanzat |
| LlamaIndex | L-aktar sempliċi għal RAG, ġestjoni nattiva ta’ dokumenti strutturati | Bidu mgħaġġel, bdiewa |
| Haystack | Approċċ ta’ pipeline modulari, qawwi fl-evalwazzjoni | Dispjegament fil-produzzjoni |
Passi li Jmiss
Issa għandek il-bażi kollha biex tibni sistemi RAG ma’ Mistral AI. Taf kif tikkodifika t-test b’mistral-embed u l-1024 dimensjoni tiegħu, tikkodifika l-kodiċi b’codestral-embed u d-dimensjonijiet konfigurabbli tiegħu sa 3072, tibni RAG mill-bidu fuq FAISS u l-API ta’ Mistral, imbagħad issaħħaħ b’arkitetturi Korrettivi, Awto, u Adattattivi. Din il-lezzjoni finali żżid it-triq tal-qafas: LangChain, LlamaIndex, u Haystack.
Biex tmur aktar ‘il quddiem, esplora l-cookbooks uffiċjali ta’ Mistral AI kif ukoll in-notebooks għal kull qafas, li jsegwu l-evoluzzjoni tal-API aktar mill-qrib minn kwalunkwe kors. RAG huwa qasam li jiċċaqlaq malajr: it-tekniki tal-qsim, tal-irkupru, u tal-verifika jitjiebu kontinwament, u huwa preċiżament għaliexiktebt kull pass b’iddejk li tkun tista’ tevalwa li jmiss li jidher.
Punti Ewlenin
- LangChain + LangGraph hija l-għażla primarja għal flussi ta’ kontroll avvanzati ta’ RAG
- LlamaIndex huwa l-aktar sempliċi għal RAG standard ma’ Mistral
- Haystack jeċċella fil-modularità u fl-evalwazzjoni tal-pipeline
- It-tliet qafas kollha jappoġġjaw nattivamente mistral-embed u mistral-large
- Ibda b’RAG mill-bidu biex tifhem, imbagħad immigra għal qafas għall-produzzjoni
Ittestja l-Għarfien Tiegħek
Embeddings, RAG, u varjanti avvanzati: l-eżami finali kbir.
1. X'inhuma ż-żewġ mudelli ta' embedding ta' Mistral, u għal xiex iservu?
Tweġiba: mistral-embed għal test ġenerali, codestral-embed għall-kodiċi—kull wieħed jipproġetta d-dominju tiegħu f’ispazju fejn titkejjel is-similarità semantika.
2. Liema passi jiffurmaw il-pipeline RAG tal-kors?
Tweġiba: Ipprepara d-data (qsim), oħloq embeddings, aħżinhom f’ħażna tal-vetturi (FAISS), imbagħad irkupru + ġenerazzjoni: il-mistoqsija ssib il-passaġġi tagħha, il-mudell iwieġeb ibbażat fuqhom.
3. X'jiswilha Corrective RAG?
Tweġiba: Irkupri ħżiena: tevalwa r-rilevanza tal-passaġġi rkuprati u ttriggera korrezzjoni (tiftix ġdid, riformulazzjoni) qabel ma tiġġenera—minflok ma twieġeb fuq storbju.
4. Self-RAG u Adaptive RAG: x'inhi l-idea komuni?
Tweġiba: Agħmel il-pipeline riflessiv: iddeċiedi meta tirrikupra, ikkritika l-output tiegħek stess, adatta l-istrateġija għall-mistoqsija—RAG tieqaf milli jkun pajp fiss.
5. X'iġibu LangChain, LlamaIndex, jew Haystack?
Tweġiba: Għodod: komponenti lesti għall-inġestjoni, indiċi, ktajjen, u evalwazzjoni—utli għall-veloċità, sakemm tifhem x’iqabbdu (li dan il-kors għallmek).
Issa taf tibni RAG b’idejk u tafdah lil qafas b’għarfien sħiħ—dik hija l-ordni t-tajba.