RAG Frameworks: LangChain, LlamaIndex, Haystack
На тази страница
Отвъд RAG от нулата
Изградихте цялостен RAG конвейер на чист Python и това беше правилният път: сега знаете какво прави всеки ред, къде се крият грешките в подравняването и защо лошо разделеното парче текст съсипва отговора. В производствена среда обаче можете да разчитате и на специализирани框架, които поемат техническата инфраструктура и добавят разширени функции. Трите основни – LangChain, LlamaIndex и Haystack – са съвместими с Mistral AI, а изборът между тях зависи по-малко от качеството, а повече от типа приложение, към което се стремите.
LangChain с Mistral
LangChain е най-популярният框架 за приложения с големи езикови модели (LLM). Неговата основна сила е широчината на екосистемата му за интеграции, допълнена от модула LangGraph за усъвършенствани потоци на управление. Инсталационният пакет включва ядрото, конектора за Mistral, интеграциите от общността и FAISS.
pip install langchain langchain-mistralai langchain-community faiss-cpu
Минималният RAG се събира в около тридесет реда, като целта е да видите какво е изчезнало в сравнение с вашата ръчна имплементация. Пакетирането, повторните опити, конвертирането към float32, подравняването между векторите и метаданните: всичко това се поема от FAISS.from_texts. RecursiveCharacterTextSplitter замества вашите функции за разделяне със същите параметри както преди – 1500 знака и 200 припокриване. Крайната верига се записва с оператора за тръбопровод (pipe), който композира стъпките от ляво надясно: извличачът подава контекста, RunnablePassthrough предава въпроса както си е, промптът ги сглобява, моделът генерира, а парсърът извлича низа.
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 за корективен, собствен и адаптивен RAG
Горната линейна верига работи за стандартен RAG, но не може да прави цикли или разклонения – а точно това правят архитектурите от предходните три урока. LangGraph решава този проблем, дефинирайки потоци на управление като графи. Типизираният GraphState действа като споделена памет: всеки възел го получава, прочита каквото му трябва и връща полетата, които актуализира. Ще разпознаете собствените си функции зад retrieve_node, grade_node и generate_node, като grade_document се използва както си е.
Наистина новият механизъм е add_conditional_edges. Докато вашият Python клас верижно изпълняваше if инструкции, графикът декларира функция за вземане на решение – тук route_after_grade – и таблица с възможните дестинации. Това разделяне между бизнес логиката на възлите и топологията на потока прави конвейера четим с един поглед и лесен за модифициране, без да се пипа кодът на стъпките. След компилация графикът се извиква като обикновена функция.
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 с Mistral
LlamaIndex отвежда абстракцията по-далеч, тъй като е оптимизиран специално за RAG и управление на структурирани документи.
pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai
Конфигурацията става чрез глобален обект Settings, който задава модела за генериране и модела за вграждане веднъж завинаги. SimpleDirectoryReader зарежда цяла директория, отгатвайки форматите, а VectorStoreIndex.from_documents верижно изпълнява разделянето и кодирането, без да се налага да ги параметризирате. Печалбата в краткостта е реална, но преценете какво означава това: стратегията за разделяне, за която вече знаете, че определя качеството на извличане, тук се избира вместо вас. Удобно е за начало, но това е първата настройка, която ще трябва да поемете отново в ръцете си в деня, в който отговорите разочароват. Обърнете внимание, че response.source_nodes запазва метаданните, оттук и проследимостта, която имплементирахте ръчно.
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 с Mistral
Haystack, разработен от deepset, възприема трета философия: тази на модулни конвейери, където всеки компонент се именува, добавя и след това изрично се свързва със съседите си.
pip install haystack-ai mistral-haystack
Конвейерът за индексиране по-долу илюстрира добре този подход. Декларират се три компонента – разделителят, енкодерът чрез MistralDocumentEmbedder и записващият в хранилището на документи – след което се свързват чрез извиквания на connect, които правят потока на данни видим в кода. Тази многословност, която може да изглежда излишна в прост случай, се превръща в актив, щом конвейерът се разклони или се наложи да замените връзка, без да пипате другите. Също така обърнете внимание на разликата между MistralDocumentEmbedder и MistralTextEmbedder: първият кодира документите по време на индексиране, вторият ще кодира заявките по време на запитване – разделение, което предотвратява класическата грешка да се третират и двете по един и същи начин.
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")
Кой да изберете
Всеки框架 има своите силни страни, а таблицата по-долу обобщава компромисите.
| Framework | Основна сила | Идеален случай на употреба |
|---|---|---|
| LangChain | Най-богата екосистема, LangGraph за сложни потоци на управление | Агенти и усъвършенстван RAG |
| LlamaIndex | Най-прост за RAG, нативна обработка на структурирани документи | Бърз старт, начинаещи |
| Haystack | Модулен подход към конвейерите, силен в оценяването | Разполагане в производствена среда |
Следващи стъпки
Сега разполагате с всички основи за изграждане на RAG системи с Mistral AI. Знаете как да кодирате текст с mistral-embed и неговите 1024 измерения, да кодирате код с codestral-embed и неговите конфигуруеми измерения до 3072, да изградите RAG от нулата върху FAISS и Mistral API, след което да го укрепите с архитектури за корективен, собствен и адаптивен RAG. Този последен урок добавя пътя чрез frameworks: LangChain, LlamaIndex и Haystack.
За да продължите напред, разгледайте официалните готварски книги (cookbooks) на Mistral AI, както и тетрадките (notebooks) за всеки framework, които следят еволюцията на API по-отблизо от всеки курс. RAG е бързо развиваща се област: техниките за разделяне, извличане и проверка се подобряват постоянно и именно защото сте написали всяка стъпка ръчно, ще можете да оцените следващата, която се появи.
Ключови изводи
- LangChain + LangGraph е основният избор за усъвършенствани потоци на управление в RAG
- LlamaIndex е най-простият за стандартен RAG с Mistral
- Haystack блести с модулност и оценяване на конвейери
- И трите frameworks поддържат нативно mistral-embed и mistral-large
- Започнете с RAG от нулата, за да разберете, след което преминете към framework за производство
Проверете знанията си
Вграждания, RAG и усъвършенствани варианти: големият финален изпит.
1. Кои са двата модела за вграждане на Mistral и за какво служат?
Отговор: mistral-embed за общ текст, codestral-embed за код – всеки проектира своя домейн в пространство, където се измерва семантичното сходство.
2. От какви стъпки се състои RAG конвейерът в курса?
Отговор: Подготовка на данни (разделяне), създаване на вграждания, съхраняването им във векторно хранилище (FAISS), след което извличане + генериране: въпросът намира своите пасажи, моделът отговаря въз основа на тях.
3. Какво поправя Corrective RAG?
Отговор: Лошите извличания: той оценява релевантността на извлечените пасажи и задейства корекция (ново търсене, преформулиране) преди генерирането – вместо да отговаря върху шум.
4. Self-RAG и Adaptive RAG: каква е общата идея?
Отговор: Да направят конвейера рефлексивен: да решават кога да извличат, да критикуват собствените си изходи, да адаптират стратегията към въпроса – RAG спира да бъде фиксирана тръба.
5. Какво носят LangChain, LlamaIndex или Haystack?
Отговор: Инструменти: готови компоненти за поглъщане, индекси, вериги и оценяване – полезни за скорост, при условие че разбирате какво сглобяват (което този курс ви научи).
Сега знаете как да изградите RAG на ръка и да го поверите на framework с пълно съзнание – това е правилният ред.