Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Qafas RAG: LangChain, LlamaIndex, Haystack

Lezzjoni 18 / 18 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Lil hinn minn RAG mill-bidu
  2. LangChain ma’ Mistral
  3. LlamaIndex ma’ Mistral
  4. Haystack ma’ Mistral
  5. Liema wieħed tagħżel?
  6. Passi li Jmiss
  7. Punti Ewlenin
  8. Ittestja l-Għarfien Tiegħek

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.

FrameworkSaħħa PrinċipaliL-Aħjar Użu
LangChainL-aktar ekosistema rikka, LangGraph għal flussi ta’ kontroll kumplessiAġenti u RAG avvanzat
LlamaIndexL-aktar sempliċi għal RAG, ġestjoni nattiva ta’ dokumenti strutturatiBidu mgħaġġel, bdiewa
HaystackApproċċ ta’ pipeline modulari, qawwi fl-evalwazzjoniDispjegament 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.