Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Creatlach RAG: LangChain, LlamaIndex, Haystack

Ceacht 18 as 18 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Níos faide ná RAG ón mbun
  2. LangChain le Mistral
  3. LlamaIndex le Mistral
  4. Haystack le Mistral
  5. Cé acu ceann a roghnú
  6. Na Chéad Chéimeanna Eile
  7. Príomhphointí
  8. Tástáil do Chuid Eolais

Níos faide ná RAG ón mbun

Chuir tú píblíne RAG iomlán le chéile i bPython íon, agus ba é sin an bealach ceart: tá a fhios agat anois cad a dhéanann gach líne, cá bhfuil earráidí ailínithe i bhfolach, agus cén fáth a scriosann smután mí-oiriúnach freagra. Sa táirgeadh, is féidir leat brath freisin ar chreatlacha speisialaithe a láimhseálann an píobaireacht agus a chuireann gnéithe casta leis. Is iad na trí phríomhcheann—LangChain, LlamaIndex, agus Haystack—comhoiriúnach go léir le Mistral AI, agus braitheann an rogha eatarthu níos mó ar an gcineál feidhmchláir atá á spriocadh agat ná ar cháilíocht.

LangChain le Mistral

Is é LangChain an creatlach is coitianta d’fheidhmchláir LLM. Is é a phríomhneart méid a éiceachórais comhtháthaithe, atá comhlánaithe ag an modúl LangGraph do shreafaí rialaithe ardscoile. Cuimsíonn an pacáiste suiteála an croí-líon, an t-ionsaitheoir Mistral, comhtháthuithe pobail, agus FAISS.

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

Feileann an RAG íosta isteach i dtríocha líne nó mar sin, agus is é an pointe ná a fheiceáil cad a d’imigh i gcomparáid le do chur i bhfeidhm láimhe. Baitseáil, iarratais athfhillteacha, tiontú go float32, ailíniú idir veicteoirí agus meiteashonraí: tá gach rud díobh seo á ionsú ag FAISS.from_texts. Cuireann RecursiveCharacterTextSplitter do fheidhmeanna smután in ionad leis na paraiméadair chéanna agus a bhí ann roimhe, 1500 carachtar agus 200 forluí. Scríobhtar an slabhra deiridh leis an oibreoir píobáin, a chumasc céimeanna ó chlé go deas: beathaíonn an t-aisghabhálaí an comhthéacs, scaipeann RunnablePassthrough an cheist mar atá, déanann an leid iad a chur le chéile, gineann an tsamhail, agus baineann an parsálaí an teaghrán amach.

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 models
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)

# Splitting and indexing
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Create the vector store
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

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

Question: {question}

Answer based on the context."""
)

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

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

LangGraph le haghaidh RAG Ceartaitheach, Féin, agus Oiriúnaitheach

Oibríonn an slabhra líneach thuas do RAG caighdeánach, ach ní féidir leis lúba nó craobhacha a dhéanamh—agus sin díreach a dhéanann na hailtireachtaí sna trí cheacht roimhe seo. Freagraíonn LangGraph ar an ngá seo trí shreafaí rialaithe a shainiú mar ghraif. Feidhmíonn an GraphState clóscríofa mar chuimhne roinnte: faigheann gach nóid é, léann sé an rud a theastaíonn uaidh, agus filleann sé na réimsí a nuashonraíonn sé. Aithneoidh tú do chuid feidhmeanna féin taobh thiar de retrieve_node, grade_node, agus generate_node, agus grade_document á athúsáid mar a bhí.

Is é add_conditional_edges an mheicníocht atá nua go hiomlán. Áit ar chuir do rang Python ráitis if i slabhra, dearann an graf feidhm chinntitheoireachta—anseo route_after_grade—agus an tábla de cheann scríbe féideartha. Déanann an deighilt seo idir loighic ghnó na nóid agus topolaíocht an tsreafa an phíblíne inléite ag amharc amháin agus in-athraithe gan teagmháil a dhéanamh le cód na céime. Nuair a thiomsaítear é, tugtar glaoh ar an ngraf cosúil le feidhm shimplí.

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

def grade_node(state):
    """Document grading node."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Use the LLM to evaluate relevance
        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):
    """Generation node."""
    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):
    """Conditional decision after grading."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Build the graph
workflow = StateGraph(GraphState)

# Add nodes
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Define the flow
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)

# Compile
app = workflow.compile()

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

LlamaIndex le Mistral

Brúnn LlamaIndex an teibíocht níos faide toisc go bhfuil sé optamaithe go sonrach do RAG agus do bhainistiú cáipéisí struchtúrtha.

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

Tarlaíonn an chumraíocht trí oibiacht dhomhanda Settings a shocraíonn an tsamhail ghiniúna agus an tsamhail leabaithe uair amháin agus go deo. Luchtaíonn SimpleDirectoryReader comhadlann iomlán trí fhormáidí a thuar, agus slabhraíonn VectorStoreIndex.from_documents smutánú agus ionchódú gan ort iad a pharaiméadrú. Tá an gnóthachan i ngiorracht fíor, ach tomhais cad a chiallaíonn sé: roghnaítear an straitéis smutánaithe duit anseo, rud a bhfuil a fhios agat anois a chinneann cáilíocht an aisghabhála. Tá sé compordach chun tosú, agus is é an chéad socrú a bheidh ort a ghlacadh ar ais i do lámha féin an lá a bheidh na freagraí míshásúil. Tabhair faoi deara go gcaomhnaíonn response.source_nodes meiteashonraí, dá bhrí sin an inrianaitheacht a chuir tú i bhfeidhm de láimh.

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

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

# Load documents
documents = SimpleDirectoryReader("./data/").load_data()

# Create the index (automatic chunking + embedding)
index = VectorStoreIndex.from_documents(documents)

# Create the query engine
query_engine = index.as_query_engine(similarity_top_k=3)

# Ask a question
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")

Haystack le Mistral

Glacann Haystack, arna fhorbairt ag deepset, tríú fealsúnacht: sin na bpíblíní modúlacha, áit a n-ainmnítear gach comhpháirt, a chuirtear leis í, agus ansin a nasctar go sainráite lena comharsana í.

pip install haystack-ai mistral-haystack

Léiríonn an phíblíne innéacsaithe thíos an cur chuige seo go maith. Dearadh trí chomhpháirt—an roinnteoir, an t-ionchódóir trí MistralDocumentEmbedder, agus an scríbhneoir chuig an stóras cáipéisí—ansin nascadh iad le glaonna connect a dhéanann sreabhadh na sonraí infheicthe sa chód. Is sócmhainn é an foclóireacht seo, a d’fhéadfadh a bheith gan ghá ar chás simplí, a luaithe a chraobhaíonn an phíblíne nó nuair a theastaíonn uait nasc a athsholáthar gan teagmháil a dhéanamh leis na cinn eile. Tabhair faoi deara freisin an difríocht idir MistralDocumentEmbedder agus MistralTextEmbedder: ionchódaíonn an chéad cheann cáipéisí ag am innéacsaithe, agus ionchódóidh an ceann eile ceisteanna ag am an cheistithe, deighilt a choscann an earráid chlasaiceach maidir le gach cás a láimhseáil ar an mbealach céanna.

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

# Document store
doc_store = InMemoryDocumentStore()

# Indexing pipeline
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")

Cé acu ceann a roghnú

Tá buanna ag gach creatlach, agus déanann an tábla thíos achoimre ar an malartú.

CreatlachPríomhbhuanAn Spota Milis
LangChainÉiceachóras is saibhre, LangGraph do shreafaí rialaithe castaGníomhairí agus RAG ardscoile
LlamaIndexIs simplí do RAG, láimhseáil dhúchasach ar cháipéisí struchtúrthaTosú tapa, túsaitheoirí
HaystackCur chuige píobaireachta modúlaí, láidir ar mheastóireachtImscaradh táirgeachta

Na Chéad Chéimeanna Eile

Tá na bunúsaigh go léir agat anois chun córais RAG a thógáil le Mistral AI. Tá a fhios agat conas téacs a ionchódú le mistral-embed agus a 1024 toise, cód a ionchódú le codestral-embed agus a thoiseanna inchoigeartaithe suas go 3072, RAG a thógáil ón mbun ar FAISS agus ar API Mistral, agus ansin é a dhaingniú le hailtireachtaí Ceartaitheacha, Féin, agus Oiriúnaitheacha. Cuireann an ceacht deiridh seo an bealach creatlaigh leis: LangChain, LlamaIndex, agus Haystack.

Chun dul níos faide, déan iniúchadh ar leabhair cócaireachta oifigiúla Mistral AI chomh maith leis na nótaí leabhair do gach creatlach, a leanann éabhlóid an API níos dlúithe ná aon chúrsa. Is réimse atá ag gluaiseacht go tapa é RAG: feabhsaíonn teicnící smutánaithe, aisghabhála, agus fíoraithe i gcónaí, agus is díreach toisc gur scríobh tú gach céim de láimh a bheidh tú in ann an chéad cheann eile a thiocfas chun cinn a mheas.

Príomhphointí

  • Is é LangChain + LangGraph an príomhrogha do shreafaí rialaithe RAG ardscoile
  • Is é LlamaIndex an ceann is simplí do RAG caighdeánach le Mistral
  • Sáraíonn Haystack i modúlacht agus i meastóireacht píobaireachta
  • Tacaíonn na trí chreatlach go dúchasach le mistral-embed agus mistral-large
  • Tosaigh le RAG ón mbun chun tuiscint a fháil, ansin imirce go creatlach don táirgeadh

Tástáil do Chuid Eolais

Leabaithe, RAG, agus leaganacha ardscoile: an scrúdú mór deiridh.

1. Cad iad an dá shamhail leabaithe ó Mistral, agus cad iad a úsáid?

Freagra: mistral-embed do théacs ginearálta, codestral-embed do chód—tionscnaíonn gach ceann a fhearann isteach i spás ina dtomhaistear cosúlacht shéimeantach.

2. Cad iad na céimeanna a dhéanann suas píblíne RAG an chúrsa?

Freagra: Ullmhaigh sonraí (smutánú), cruthaigh leabaithe, stóráil iad i stóras veicteoir (FAISS), ansin aisghabháil + giniúint: faigheann an cheist a pasanna, freagraíonn an tsamhail bunaithe orthu.

3. Cad a dheisíonn RAG Ceartaitheach?

Freagra: Aisghabhálacha bochta: déanann sé meastóireacht ar ábharthacht na bpasanna a aisghabhadh agus spreagann sé ceartúchán (cuardach nua, athfhoirmliú) sula ngintear—in ionad freagra a thabhairt ar thorann.

4. Féin-RAG agus RAG Oiriúnaitheach: cad é an smaoineamh coiteann?

Freagra: Déan an phíblíne frithchaiteach: cinntigh cathain le haisghabháil, cáin a chuid aschur féin, oiriúnaigh an straitéis don cheist—stopann RAG bheith ina phíobán seasta.

5. Cad a thugann LangChain, LlamaIndex, nó Haystack?

Freagra: Uirlisí: comhpháirteanna réamhdhéanta d’ionghabháil, innéacsanna, slabhraí, agus meastóireacht—úsáideach ar mhaithe le luas, ar choinníoll go dtuigeann tú cad a chuireann siad le chéile (rud a mhúin an cúrsa seo duit).

Tá a fhios agat anois conas RAG a thógáil de láimh agus é a chur ar iontaoibh creatlaigh le feasacht iomlán—sin an t-ord ceart.