Salt la conținutul principal
Română— Alege o limbă
Meniu

Framework-uri RAG: LangChain, LlamaIndex, Haystack

Lecția 18 din 18 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Dincolo de RAG construit de la zero
  2. LangChain cu Mistral
  3. LlamaIndex cu Mistral
  4. Haystack cu Mistral
  5. Pe care să îl alegeți
  6. Pașii următori
  7. Puncte cheie
  8. Testați-vă cunoștințele

Dincolo de RAG construit de la zero

Ați construit un pipeline RAG complet în Python pur, iar aceasta a fost calea corectă: acum știți ce face fiecare linie, unde se ascund erorile de aliniere și de ce un chunk tăiat necorespunzător ruinează un răspuns. În producție, vă puteți baza însă și pe framework-uri specializate care gestionează partea tehnică complexă și adaugă funcționalități avansate. Cele trei principale—LangChain, LlamaIndex și Haystack—sunt toate compatibile cu Mistral AI, iar alegerea dintre ele depinde mai puțin de calitate și mai mult de tipul de aplicație pe care îl vizați.

LangChain cu Mistral

LangChain este cel mai popular framework pentru aplicațiile LLM. Principala sa forță constă în amploarea ecosistemului său de integrări, completat de modulul LangGraph pentru fluxuri de control avansate. Instalarea include nucleul, conectorul Mistral, integrările comunitare și FAISS.

pip install langchain langchain-mistralai langchain-community faiss-cpu

RAG-ul minimal se încadrează apoi în aproximativ treizeci de linii, iar scopul este să observați ce a dispărut comparativ cu implementarea manuală. Batch-processing, reîncercări, conversia la float32, alinierea dintre vectori și metadate: toate acestea sunt absorbite de FAISS.from_texts. RecursiveCharacterTextSplitter înlocuiește funcțiile dumneavoastră de chunking cu aceiași parametri ca înainte, 1500 de caractere și 200 de suprapunere. Lanțul final este scris cu operatorul pipe, care compune pașii de la stânga la dreapta: retriever-ul furnizează contextul, RunnablePassthrough circulă întrebarea așa cum este, promptul le asamblează, modelul generează, iar parserul extrage șirul de caractere.

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

# Modele Mistral
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)

# Divizare și indexare
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Crearea stocului vectorial
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# Lanț RAG
prompt = ChatPromptTemplate.from_template(
    """Context: {context}

Question: {question}

Answer based on the context."""
)

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# Utilizare
answer = rag_chain.invoke("How does FAISS work?")
print(answer)

LangGraph pentru RAG Corectiv, Auto și Adaptiv

Lanțul liniar de mai sus funcționează pentru RAG standard, dar nu poate crea bucle sau ramificații—și totuși, exact asta fac arhitecturile din cele trei lecții precedente. LangGraph răspunde acestei nevoi definind fluxuri de control sub formă de grafuri. GraphState tipizat acționează ca o memorie partajată: fiecare nod îl primește, citește ce are nevoie și returnează câmpurile pe care le actualizează. Veți recunoaște propriile funcții în spatele lui retrieve_node, grade_node și generate_node, cu grade_document reutilizat ca atare.

Mecanismul cu adevărat nou este add_conditional_edges. Acolo unde clasa dumneavoastră Python înlănțuia instrucțiuni if, graful declară o funcție de decizie—aici route_after_grade—și tabelul destinațiilor posibile. Această separare între logica de business a nodurilor și topologia fluxului face pipeline-ul lizibil la prima vedere și modificabil fără a atinge codul pasului. Odată compilat, graful este invocat ca o simplă funcție.

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):
    """Nod de recuperare."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Nod de evaluare a documentelor."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Utilizarea LLM pentru a evalua relevanța
        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):
    """Nod de generare."""
    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):
    """Decizie condiționată după evaluare."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Construirea grafului
workflow = StateGraph(GraphState)

# Adăugarea nodurilor
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Definirea fluxului
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)

# Compilare
app = workflow.compile()

# Executare
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])

LlamaIndex cu Mistral

LlamaIndex împinge abstractizarea mai departe, fiind optimizat specific pentru RAG și gestionarea documentelor structurate.

pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai

Configurarea se face printr-un obiect global Settings care setează o dată pentru totdeauna modelul de generare și modelul de embedding. SimpleDirectoryReader încarcă un întreg director ghicind formatele, iar VectorStoreIndex.from_documents înlănțuie chunking-ul și codificarea fără ca dumneavoastră să trebuiască să le parametrizați. Câștigul în concizie este real, dar măsurați implicațiile: strategia de divizare, despre care știți acum că determină calitatea recuperării, este aleasă aici pentru dumneavoastră. Este confortabil pentru început, dar este prima setare pe care va trebui să o reluați în mână în ziua în care răspunsurile dezamăgesc. Rețineți că response.source_nodes păstrează metadatele, deci trasabilitatea pe care ați implementat-o manual.

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

# Configurare globală
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")

# Încărcarea documentelor
documents = SimpleDirectoryReader("./data/").load_data()

# Crearea indexului (chunking + embedding automat)
index = VectorStoreIndex.from_documents(documents)

# Crearea motorului de interogare
query_engine = index.as_query_engine(similarity_top_k=3)

# Punerea unei întrebări
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")

Haystack cu Mistral

Haystack, dezvoltat de deepset, adoptă o a treia filozofie: cea a pipeline-urilor modulare, unde fiecare componentă este numită, adăugată și apoi conectată explicit la vecinii săi.

pip install haystack-ai mistral-haystack

Pipeline-ul de indexare de mai jos ilustrează bine această abordare. Trei componente sunt declarate—divizorul, encoder-ul prin MistralDocumentEmbedder și scriitorul în stocul de documente—apoi legate prin apeluri connect care fac fluxul de date vizibil în cod. Această verbositate, care poate părea inutilă într-un caz simplu, devine un atu imediat ce pipeline-ul se ramifică sau trebuie să înlocuiți o legătură fără a le atinge pe celelalte. De asemenea, remarcați distincția dintre MistralDocumentEmbedder și MistralTextEmbedder: primul codifică documentele la momentul indexării, al doilea va codifica interogările la momentul consultării, o separare care previne eroarea clasică de a le trata pe ambele la fel.

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

# Stoc de documente
doc_store = InMemoryDocumentStore()

# Pipeline de indexare
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")

Pe care să îl alegeți

Fiecare framework are punctele sale forte, iar tabelul de mai jos rezumă compromisurile.

FrameworkPunctul forte principalDomeniul ideal
LangChainCel mai bogat ecosistem, LangGraph pentru fluxuri de control complexeAgenți și RAG avansat
LlamaIndexCel mai simplu pentru RAG, gestionare nativă a documentelor structurateÎnceput rapid, începători
HaystackAbordare modulară prin pipeline-uri, puternic în evaluareImplementare în producție

Pașii următori

Aveți acum toate bazele pentru a construi sisteme RAG cu Mistral AI. Știți cum să codificați textul cu mistral-embed și cele 1024 de dimensiuni ale sale, să codificați codul cu codestral-embed și dimensiunile sale configurabile până la 3072, să construiți un RAG de la zero pe FAISS și API-ul Mistral, apoi să îl consolidați cu arhitecturi Corective, Auto și Adaptive. Această lecție finală adaugă calea framework-urilor: LangChain, LlamaIndex și Haystack.

Pentru a merge mai departe, explorați cookbooks-urile oficiale Mistral AI, precum și notebook-urile pentru fiecare framework, care urmăresc evoluția API-ului mai îndeaproape decât orice curs. RAG este un domeniu în mișcare rapidă: tehnicile de chunking, recuperare și verificare se îmbunătățesc constant, și tocmai pentru că ați scris fiecare pas manual veți putea evalua următorul care apare.

Puncte cheie

  • LangChain + LangGraph este alegerea principală pentru fluxuri de control RAG avansate
  • LlamaIndex este cel mai simplu pentru RAG standard cu Mistral
  • Haystack excelează în modularitate și evaluarea pipeline-urilor
  • Toate cele trei framework-uri suportă nativ mistral-embed și mistral-large
  • Începeți cu RAG construit de la zero pentru a înțelege, apoi migrați către un framework pentru producție

Testați-vă cunoștințele

Embeddings, RAG și variante avansate: examenul final grandios.

1. Care sunt cele două modele de embedding ale Mistral și la ce servesc?

Răspuns: mistral-embed pentru text general, codestral-embed pentru cod—fiecare proiectează domeniul său într-un spațiu unde se măsoară similaritatea semantică.

2. Ce pași compun pipeline-ul RAG din acest curs?

Răspuns: Pregătirea datelor (chunking), crearea embedding-urilor, stocarea lor într-un store vectorial (FAISS), apoi recuperare + generare: întrebarea își găsește pasajele, modelul răspunde pe baza lor.

3. Ce repară Corrective RAG?

Răspuns: Recuperările slabe: evaluează relevanța pasajelor recuperate și declanșează o corecție (nouă căutare, reformulare) înainte de generare—în loc să răspundă pe baza zgomotului.

4. Self-RAG și Adaptive RAG: care este ideea comună?

Răspuns: Să facă pipeline-ul reflexiv: să decidă când să recupereze, să își critice propriile ieșiri, să adapteze strategia la întrebare—RAG încetează să mai fie o țeavă fixă.

5. Ce aduc LangChain, LlamaIndex sau Haystack?

Răspuns: Unelte: componente gata făcute pentru ingestie, indexuri, lanțuri și evaluare—utile pentru viteză, cu condiția să înțelegeți ce asamblează (ceea ce v-a învățat acest curs).

Acum știți cum să construiți un RAG manual și să îl încredințați unui framework cu deplină conștiință—aceasta este ordinea corectă.