# Сравнение RAG-фреймворков

Выберите подходящий фреймворк Retrieval-Augmented Generation (RAG) для вашего проекта на GPU-серверах Clore.ai.

{% hint style="info" %}
**RAG (Retrieval-Augmented Generation)** позволяет LLM отвечать на вопросы с использованием ваших документов. Это руководство сравнивает четыре ведущих фреймворка: LangChain, LlamaIndex, Haystack и RAGFlow — охватывая функции, производительность и сценарии использования каждого.
{% endhint %}

***

## Краткая матрица принятия решений

|                          | LangChain            | LlamaIndex                     | Haystack              | RAGFlow                        |
| ------------------------ | -------------------- | ------------------------------ | --------------------- | ------------------------------ |
| **Лучше всего для**      | Общие LLM-приложения | Вопросы и ответы по документам | Поиск для предприятия | Самостоятельно размещаемый RAG |
| **Кривая обучения**      | Средне               | Низкая‑Средняя                 | Средняя‑Высокая       | Низкая                         |
| **Гибкость**             | Очень высокая        | Высокая                        | Высокая               | Средне                         |
| **Встроенный интерфейс** | Нет                  | Нет                            | Нет                   | Да                             |
| **Звезды на GitHub**     | 90K+                 | 35K+                           | 15K+                  | 12K+                           |
| **Язык**                 | Python               | Python                         | Python                | Python                         |
| **Лицензия**             | MIT                  | MIT                            | Apache 2.0            | Apache 2.0                     |

***

## Обзор

### LangChain

LangChain — самый популярный фреймворк для оркестрации LLM. Он предоставляет единый интерфейс для цепочек, агентов, памяти и RAG‑конвейеров.

**Философия**: Всё — это цепочка составных компонентов.

```python
from langchain.chains import RetrievalQA
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI

# Построить RAG‑конвейер в 5 строк
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(docs, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
chain = RetrievalQA.from_chain_type(llm=OpenAI(), retriever=retriever)
result = chain.run("Какова столица Франции?")
```

### LlamaIndex

LlamaIndex (ранее GPT Index) специально создан для индексирования и поиска по документам. Он прекрасно справляется с подключением LLM к разнообразным источникам данных.

**Философия**: Сначала индекс, затем интеллектуальный запрос.

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Загрузить и проиндексировать документы
documents = SimpleDirectoryReader("data/").load_data()
index = VectorStoreIndex.from_documents(documents)

# Запрос
query_engine = index.as_query_engine()
response = query_engine.query("Суммируй основные выводы")
print(response)
```

### Haystack

Haystack (от deepset) — корпоративный NLP‑фреймворк, ориентированный на поиск и конвейеры Q\&A. Имеет компонентную архитектуру с визуальным конструктором конвейеров.

**Философия**: Модульные конвейеры с корпоративной надёжностью.

```python
from haystack.nodes import DensePassageRetriever, FARMReader
from haystack.pipelines import ExtractiveQAPipeline

retriever = DensePassageRetriever(document_store=document_store)
reader = FARMReader(model_name_or_path="deepset/roberta-base-squad2")
pipeline = ExtractiveQAPipeline(reader, retriever)
result = pipeline.run(query="Что такое машинное обучение?", params={"Retriever": {"top_k": 10}})
```

### RAGFlow

RAGFlow — это open-source движок RAG со встроенным веб-интерфейсом, парсингом документов и управлением базой знаний. Он разработан для развёртывания как готовое решение.

**Философия**: RAG‑система из коробки, без необходимости писать код.

```yaml
# RAGFlow разворачивается через Docker Compose
# Конфигурация через веб‑интерфейс по адресу localhost:80
version: "3"
services:
  ragflow:
    image: infiniflow/ragflow:latest
    ports:
      - "80:80"
    volumes:
      - ./ragflow-data:/ragflow/data
```

***

## Сравнение функций

### Основные функции RAG

| Функция                      | LangChain | LlamaIndex | Haystack | RAGFlow  |
| ---------------------------- | --------- | ---------- | -------- | -------- |
| Поддержка векторных хранилищ | 50+       | 30+        | 20+      | Встроено |
| Загрузчики документов        | 100+      | 50+        | 30+      | Встроено |
| Гибридный поиск              | ✅         | ✅          | ✅        | ✅        |
| Переранжирование             | ✅         | ✅          | ✅        | ✅        |
| Мультимодальность            | ✅         | ✅          | Частично | ✅        |
| Потоковая передача           | ✅         | ✅          | ✅        | ✅        |
| Поддержка асинхронности      | ✅         | ✅          | ✅        | ✅        |
| Агенты                       | ✅         | ✅          | ✅        | ❌        |

### Экосистема интеграций

| Тип интеграции     | LangChain                                   | LlamaIndex                          | Haystack                         | RAGFlow                    |
| ------------------ | ------------------------------------------- | ----------------------------------- | -------------------------------- | -------------------------- |
| Провайдеры LLM     | 50+                                         | 30+                                 | 20+                              | 10+                        |
| Векторные БД       | Chroma, Pinecone, Weaviate, Qdrant, ещё 40+ | Chroma, Pinecone, Weaviate, ещё 25+ | Weaviate, Elasticsearch, ещё 15+ | Встроенный InfiniFlow      |
| Типы документов    | PDF, Web, CSV, JSON, ещё 80+                | PDF, Web, CSV, БД, ещё 40+          | PDF, TXT, HTML, ещё 20+          | PDF, Word, Excel, PPT, Web |
| Облачное хранилище | S3, GCS, Azure                              | S3, GCS, Azure                      | S3, GCS                          | S3                         |

### Расширенные функции RAG

| Функция                                      | LangChain | LlamaIndex        | Haystack | RAGFlow |
| -------------------------------------------- | --------- | ----------------- | -------- | ------- |
| Декомпозиция запроса                         | ✅         | ✅                 | ✅        | ✅       |
| HyDE (гипотетические документные эмбеддинги) | ✅         | ✅                 | ❌        | ❌       |
| Многошаговый поиск (multi-hop)               | ✅         | ✅                 | Частично | ✅       |
| Контекстуальная компрессия                   | ✅         | ✅                 | ✅        | ✅       |
| Self‑RAG                                     | ✅         | ✅                 | ❌        | ❌       |
| GraphRAG                                     | ✅         | ✅ (PropertyGraph) | ❌        | ✅       |
| Отслеживание цитирований                     | Частично  | ✅                 | Частично | ✅       |

***

## Тесты производительности

### Точность поиска (RAG‑Bench, 2024)

{% hint style="info" %}
Бенчмарки сильно варьируются в зависимости от датасета и конфигурации. Это приблизительные данные из общинных тестов.
{% endhint %}

| Фреймворк              | HotpotQA (F1) | Natural Questions (EM) | TriviaQA (Acc) |
| ---------------------- | ------------- | ---------------------- | -------------- |
| LangChain (RAG)        | \~68%         | \~42%                  | \~72%          |
| LlamaIndex (RAG)       | \~71%         | \~45%                  | \~74%          |
| Haystack (RAG)         | \~69%         | \~43%                  | \~71%          |
| RAGFlow (по умолчанию) | \~65%         | \~40%                  | \~68%          |

*Результаты сильно зависят от выбранного LLM, модели эмбеддингов и размера чанка*

### Скорость индексирования (10K документов, \~1KB каждый)

| Фреймворк  | Только CPU | GPU для эмбеддингов |
| ---------- | ---------- | ------------------- |
| LangChain  | \~120 сек  | \~18 сек            |
| LlamaIndex | \~110 сек  | \~15 сек            |
| Haystack   | \~130 сек  | \~20 сек            |
| RAGFlow    | \~150 сек  | \~25 сек            |

*С эквивалентом text-embedding-ada-002 (1536 измерений)*

### Задержка запроса (P50/P99, с предварительно построенным индексом)

| Фреймворк  | P50    | P99   | Примечания                            |
| ---------- | ------ | ----- | ------------------------------------- |
| LangChain  | 450 мс | 1.2 с | Без переранжирования                  |
| LlamaIndex | 400 мс | 1.0 с | Без переранжирования                  |
| Haystack   | 500 мс | 1.5 с | С учётом накладных расходов конвейера |
| RAGFlow    | 600 мс | 2.0 с | Включая накладные расходы UI/API      |

***

## LangChain: подробный обзор

### Сильные стороны

✅ **Самая большая экосистема** — 50+ интеграций, огромное сообщество\
✅ **Агенты и инструменты** — создание автономных AI‑агентов\
✅ **LangSmith** — отличная наблюдаемость и отладка\
✅ **LCEL** — LangChain Expression Language для составления цепочек\
✅ **Системы памяти** — история разговоров, память сущностей

### Слабые стороны

❌ **Сложность** — может быть избыточно для простых задач\
❌ **Частые ломаюшие изменения** — миграции v0.1 vs v0.2 vs v0.3\
❌ **Большая зависимость** — большой размер установки\
❌ **Протекание абстракций** — иногда сложнее отлаживать

### Лучшие сценарии использования

* Многошаговые LLM‑конвейеры со сложной логикой
* AI‑агенты, использующие инструменты (веб‑поиск, выполнение кода, API)
* Приложения, требующие памяти разговоров
* Проекты, требующие максимальной гибкости

### Пример: продвинутый RAG с источниками

```python
from langchain.chains import RetrievalQAWithSourcesChain
from langchain_community.vectorstores import Chroma
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Настройка
llm = ChatOpenAI(model="gpt-4", temperature=0)
embeddings = OpenAIEmbeddings()

# Индексировать документы с метаданными
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

vectorstore = Chroma.from_documents(
    chunks, 
    embeddings,
    persist_directory="./chroma_db"
)

# Построить цепочку с атрибуцией источников
chain = RetrievalQAWithSourcesChain.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
    return_source_documents=True
)

result = chain({"question": "Каковы основные риски?"})
print(result["answer"])
print("Источники:", result["sources"])
```

***

## LlamaIndex: подробный обзор

### Сильные стороны

✅ **Дизайн, ориентированный на документы** — лучше всего для сложного индексирования документов\
✅ **Типы индексов** — векторный, граф знаний, SQL, по ключевым словам\
✅ **Движок подзадач (sub-question engine)** — автоматически разлагает сложные запросы\
✅ **Структурированные выводы** — интеграция с Pydantic\
✅ **Маршрутизирующий движок запросов** — интеллектуально перенаправляет к нужному индексу

### Слабые стороны

❌ **Меньше ориентации на агентов** чем LangChain\
❌ **Меньшая экосистема** чем LangChain\
❌ **Документация** может быть непоследовательной

### Лучшие сценарии использования

* Системы Q\&A по документам (PDF, отчёты, вики)
* Сложное многодокументное рассуждение
* Построение графов знаний
* Мосты данных к LLM (базы данных, API)

### Пример: движок запросов по нескольким документам

```python
from llama_index.core import (
    VectorStoreIndex, 
    SimpleDirectoryReader,
    StorageContext,
    Settings
)
from llama_index.core.query_engine import RouterQueryEngine
from llama_index.core.tools import QueryEngineTool
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# Глобальная конфигурация
Settings.llm = OpenAI(model="gpt-4")
Settings.embed_model = OpenAIEmbedding()

# Создать отдельные индексы для разных наборов документов
annual_reports = SimpleDirectoryReader("./annual_reports").load_data()
tech_docs = SimpleDirectoryReader("./tech_docs").load_data()

index_reports = VectorStoreIndex.from_documents(annual_reports)
index_tech = VectorStoreIndex.from_documents(tech_docs)

# Построить маршрутизатор, который выбирает правильный индекс
tools = [
    QueryEngineTool.from_defaults(
        query_engine=index_reports.as_query_engine(),
        description="Годовые финансовые отчёты и бизнес‑метрики"
    ),
    QueryEngineTool.from_defaults(
        query_engine=index_tech.as_query_engine(),
        description="Техническая документация и справочники API"
    )
]

router = RouterQueryEngine.from_defaults(query_engine_tools=tools)
response = router.query("Каков был рост выручки в прошлом году?")
```

***

## Haystack: подробный обзор

### Сильные стороны

✅ **Корпоративного уровня** — надёжность для продакшна\
✅ **Визуальный конструктор конвейеров** — Haystack Studio\
✅ **Инструмент аннотаций** — встроенный UI для разметки\
✅ **Сильный NLP** — извлекающие QA, суммаризация\
✅ **deepset Cloud** — вариант управляемого развёртывания

### Слабые стороны

❌ **Более крутая кривая обучения** чем у конкурентов\
❌ **Меньше сообщество** чем у LangChain/LlamaIndex\
❌ **Менее гибкий** для новых архитектур

### Лучшие сценарии использования

* Корпоративный поиск по документам и Q\&A
* Проекты, требующие аудита и наблюдаемости
* Команды, желающие визуальный дизайн конвейеров
* Продакшн‑развёртывания с требованиями SLA

### Пример: гибридный поисковый конвейер

```python
from haystack import Pipeline
from haystack.components.retrievers import InMemoryBM25Retriever, InMemoryEmbeddingRetriever
from haystack.components.joiners import DocumentJoiner
from haystack.components.rankers import MetaFieldRanker
from haystack.components.generators import OpenAIGenerator
from haystack.components.builders import RAGPromptBuilder

# Построить гибридный поисковый конвейер
pipeline = Pipeline()
pipeline.add_component("bm25_retriever", InMemoryBM25Retriever(document_store=store, top_k=10))
pipeline.add_component("embedding_retriever", InMemoryEmbeddingRetriever(document_store=store, top_k=10))
pipeline.add_component("joiner", DocumentJoiner(join_mode="reciprocal_rank_fusion"))
pipeline.add_component("ranker", MetaFieldRanker(meta_field="score"))
pipeline.add_component("prompt_builder", RAGPromptBuilder())
pipeline.add_component("llm", OpenAIGenerator(model="gpt-4"))

# Соединить компоненты
pipeline.connect("bm25_retriever", "joiner.documents")
pipeline.connect("embedding_retriever", "joiner.documents")
pipeline.connect("joiner", "ranker")
pipeline.connect("ranker", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

result = pipeline.run({"bm25_retriever": {"query": "deep learning"}, 
                       "embedding_retriever": {"query": "deep learning"}})
```

***

## RAGFlow: подробный обзор

### Сильные стороны

✅ **Развёртывание без кода** — полный UI включён\
✅ **Продвинутый парсинг документов** — таблицы, изображения, графики\
✅ **Управление базой знаний** — визуальный интерфейс\
✅ **API включено** — REST API из коробки\
✅ **Agentic RAG** — встроенные агенты

### Слабые стороны

❌ **Менее настраиваемый** чем фреймворки, ориентированные на код\
❌ **Большие требования к ресурсам** (Elasticsearch + Infinity DB)\
❌ **Ограниченная поддержка LLM** по сравнению с LangChain\
❌ **Более новый проект** — меньшее сообщество

### Лучшие сценарии использования

* Неразработчики, которым нужен RAG без кодирования
* Команды, желающие готовый продукт базы знаний
* Внутренние корпоративные вики и поиск по документации
* Быстрое прототипирование RAG‑приложений

### Развертывание на Clore.ai

```yaml
# docker-compose.yml для RAGFlow
version: "3"
services:
  ragflow:
    image: infiniflow/ragflow:v0.12.0
    container_name: ragflow
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./ragflow-logs:/ragflow/logs
      - ./ragflow-data:/ragflow/data
    depends_on:
      - elasticsearch
      - infinity

  elasticsearch:
    image: elasticsearch:8.11.3
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
      - xpack.security.enabled=false
    volumes:
      - es_data:/usr/share/elasticsearch/data

  infinity:
    image: infiniflow/infinity:v0.3.0
    volumes:
      - infinity_data:/var/infinity

volumes:
  es_data:
  infinity_data:
```

```bash
docker compose up -d
# Доступ к веб‑интерфейсу по адресу http://<server-ip>:80
```

***

## Когда что использовать

### Выберите LangChain если:

* Создаёте AI‑агентов с инструментами (веб‑поиск, выполнение кода, API)
* Нужна максимальная гибкость экосистемы
* Создаёте сложные многошаговые конвейеры
* Интегрируетесь со многими разными LLM и источниками данных
* Команда комфортно работает с Python

### Выберите LlamaIndex если:

* Основной сценарий — Q\&A по документам
* Работаете со сложной структурой документов (таблицы, вложенное содержание)
* Нужны графы знаний или маршрутизация по нескольким индексам
* Хотите лучшее в классе поглощение документов
* Строите поверх структурированных данных (БД, API)

### Выберите Haystack если:

* Корпоративная среда с требованиями соответствия
* Нужны инструменты визуального построения конвейеров
* Строите поверх Elasticsearch
* Хотите извлекающий (а не только генеративный) QA
* Команде нужна наблюдаемость NLP‑конвейеров

### Выберите RAGFlow если:

* Нетехнической команде нужен самообслуживаемый RAG
* Хотите готовый продукт, а не фреймворк
* Быстрое развёртывание важнее настройки
* Создаёте внутреннюю базу знаний
* Не хотите писать код на Python

***

## Запуск на Clore.ai: требования к ресурсам

| Фреймворк  | Мин. ОЗУ     | Мин. VRAM            | Рекомендуемый GPU |
| ---------- | ------------ | -------------------- | ----------------- |
| LangChain  | 8 ГБ         | 8 ГБ (локальная LLM) | RTX 3080          |
| LlamaIndex | 8 ГБ         | 8 ГБ (локальная LLM) | RTX 3080          |
| Haystack   | 16GB         | 8 ГБ (локальная LLM) | RTX 3090          |
| RAGFlow    | 32 ГБ (ОЗУ!) | 16GB                 | A6000 / A100      |

{% hint style="warning" %}
**RAGFlow требует больше ОЗУ**: Он запускает Elasticsearch + InfinityDB + само приложение. Планируйте как минимум 32 ГБ системной памяти. Haystack с Elasticsearch также выигрывает от 16+ ГБ ОЗУ.
{% endhint %}

***

## Полезные ссылки

* [Документация LangChain](https://python.langchain.com)
* [Документация LlamaIndex](https://docs.llamaindex.ai)
* [Документация Haystack](https://docs.haystack.deepset.ai)
* [RAGFlow на GitHub](https://github.com/infiniflow/ragflow)
* [Обзорная статья по RAG (arxiv)](https://arxiv.org/abs/2312.10997)

***

## Сводная рекомендация

```
Простые Q&A по документам     → LlamaIndex
Сложные AI‑агенты             → LangChain
Корпоративный поиск           → Haystack
Продукт RAG без кода          → RAGFlow
Максимальная гибкость         → LangChain
Лучшее понимание документов   → LlamaIndex
```

Все четыре фреймворка — отличные варианты — правильный выбор зависит от ваших конкретных требований, навыков команды и ограничений развёртывания. В случае сомнений начните с **LlamaIndex** для сценариев, где много документов, или с **LangChain** если вам нужна максимально широкая экосистема.

***

## Рекомендации Clore.ai по GPU

| Сценарий использования  | Рекомендуемый GPU | Примерная стоимость на Clore.ai |
| ----------------------- | ----------------- | ------------------------------- |
| Разработка/Тестирование | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Продакшн                | RTX 4090 (24GB)   | \~$0.70/gpu/hr                  |
| Крупномасштабно         | A100 80GB         | \~$1.20/gpu/hr                  |

> 💡 Все примеры в этом руководстве можно развернуть на [Clore.ai](https://clore.ai/marketplace) GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/sravneniya/rag-frameworks-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.