Премини към основното съдържание
Български— Изберете език
Меню

RAG Frameworks: LangChain, LlamaIndex, Haystack

Урок 18 от 18 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Отвъд RAG от нулата
  2. LangChain с Mistral
  3. LlamaIndex с Mistral
  4. Haystack с Mistral
  5. Кой да изберете
  6. Следващи стъпки
  7. Ключови изводи
  8. Проверете знанията си

Отвъд 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 с пълно съзнание – това е правилният ред.