> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/rag-i-vektornye-bazy-dannykh/ragflow.md).

# RAGFlow

RAGFlow — это проект с открытым исходным кодом **движок генерации с дополненным поиском (RAG)** с возможностями глубокого понимания документов. С более чем **50 000 звёзд на GitHub**, это одна из самых комплексных RAG-платформ — она предназначена для извлечения, разбиения на фрагменты и анализа сложных документов, включая PDF, Word-файлы, таблицы, изображения и многое другое.

В отличие от базовых RAG-систем, которые наивно разбивают документы на фрагменты, RAGFlow использует разбор с учётом структуры страницы, чтобы понимать структуру документа, таблицы, иллюстрации и многоколонную верстку. Это обеспечивает значительно более высокую точность поиска и качество ответов.

Ключевые возможности:

* 📄 **Глубокое понимание документов** — OCR, извлечение таблиц, распознавание иллюстраций
* 🔍 **Несколько стратегий разбиения на фрагменты** — семантическое, с учётом структуры страницы, фиксированного размера, в формате вопрос-ответ
* 🤖 **Интеграция LLM** — работает с OpenAI, Ollama, Anthropic, локальными моделями
* 🌐 **Полнофункциональный WebUI** — управление документами перетаскиванием
* 🔌 **REST API** — интеграция RAGFlow в любое приложение
* 📊 **Отслеживание цитирования** — ответы включают ссылки на исходные документы
* 🏗️ **Мультиарендность** — командные рабочие пространства с контролем доступа

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

***

## Требования к серверу

| Параметр | Минимум                 | Рекомендуется           |
| -------- | ----------------------- | ----------------------- |
| GPU      | NVIDIA RTX 3080 (10 ГБ) | NVIDIA RTX 4090 (24 ГБ) |
| VRAM     | 8 ГБ                    | 16–24 ГБ                |
| ОЗУ      | 16 ГБ                   | 32–64 ГБ                |
| CPU      | 8 ядер                  | 16+ ядер                |
| Диск     | 50 ГБ                   | 100–500 ГБ              |
| ОС       | Ubuntu 20.04+           | Ubuntu 22.04            |
| CUDA     | 11.8+                   | 12.1+                   |
| Порты    | 22, 9380, 80            | 22, 9380, 80            |
| Docker   | Требуется               | Docker + Docker Compose |

{% hint style="warning" %}
RAGFlow запускает несколько сервисов (Elasticsearch, MinIO, MySQL, Redis, Nginx) вместе с основным приложением. Убедитесь, что у вас достаточно оперативной памяти (минимум 16 ГБ, рекомендуется 32 ГБ) и дискового пространства.
{% endhint %}

***

## Быстрое развертывание на CLORE.AI

### 1. Найдите подходящий сервер

Перейдите на [маркетплейс CLORE.AI](https://clore.ai/marketplace) и отфильтруйте по:

* **VRAM**: ≥ 8 ГБ
* **ОЗУ**: ≥ 16 ГБ
* **Диск**: ≥ 50 ГБ
* **GPU**: RTX 3090, 4090, A100, H100

### 2. Настройте своё развёртывание

**Docker-образ:**

```
infiniflow/ragflow:latest
```

**Сопоставление портов:**

```
22   → доступ по SSH
80   → Веб-интерфейс RAGFlow (HTTP)
9380 → API RAGFlow
```

**Команда запуска:**

```bash
bash -c "docker-compose -f docker/docker-compose.yml up -d"
```

### 3. Откройте WebUI

```
http://<your-clore-server-ip>:80
```

Учётные данные по умолчанию: `admin@ragflow.io` / `admin`

***

## Пошаговая настройка

### Шаг 1: Подключитесь к серверу по SSH

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

### Шаг 2: Установите Docker Compose

```bash
apt-get update && apt-get install -y docker-compose-plugin

# Проверить
docker compose version
```

### Шаг 3: Клонируйте репозиторий RAGFlow

```bash
cd /workspace
git clone https://github.com/infiniflow/ragflow.git
cd ragflow
```

### Шаг 4: Настройте окружение

```bash
# Скопируйте и отредактируйте файл окружения
cp docker/.env.example docker/.env
nano docker/.env
```

Основные параметры для настройки:

```env
# Настройка LLM
OPENAI_API_KEY=your-openai-api-key

# Или используйте локальный экземпляр Ollama
OLLAMA_BASE_URL=http://localhost:11434

# Настройки хранилища
MINIO_USER=ragflow
MINIO_PASSWORD=infini_rag_flow

# Настройки MySQL
MYSQL_PASSWORD=infini_rag_flow

# Порт приложения
HTTP_PORT=80
RAGFLOW_API_PORT=9380
```

### Шаг 5: Выберите подходящий вариант образа

```bash
# Проверьте доступные теги
# Для CUDA 12.8 (RTX 30xx, 40xx, 50xx)
docker pull infiniflow/ragflow:latest

# Для конкретной версии CUDA
docker pull infiniflow/ragflow:v0.7.0-cuda12.1
```

### Шаг 6: Запустите все сервисы

```bash
cd /workspace/ragflow/docker

# Запуск с поддержкой GPU
docker compose -f docker-compose.yml up -d

# Отслеживайте запуск (занимает 2–5 минут)
docker compose logs -f
```

Дождитесь:

```
ragflow-server | INFO: Запуск приложения завершён.
```

### Шаг 7: Создайте учётную запись администратора

Открыть `http://<server-ip>:80` и зарегистрируйте первую учётную запись администратора.

### Шаг 8: Настройте модель LLM

1. Перейдите на **Настройки → Поставщики моделей**
2. Добавьте свою LLM (OpenAI, Ollama и т. д.)
3. Установите модель чата и модель эмбеддингов по умолчанию

***

## Примеры использования

### Пример 1: Загрузка и запрос документов через WebUI

1. Войдите в `http://<server-ip>:80`
2. Нажмите **"База знаний"** → **"Создать базу знаний"**
3. Назовите её: `"Документация Clore.ai"`
4. Загрузите файлы PDF/Word/TXT с помощью перетаскивания
5. Дождитесь разбора (прогресс отображается в интерфейсе)
6. Перейдите на **"Чат"** → Создайте нового ассистента, связанного с вашей базой знаний
7. Задавайте вопросы о ваших документах

***

### Пример 2: API — создание базы знаний и загрузка документов

```python
import requests
import json
from pathlib import Path

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"  # Получите в Настройки → API

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# Шаг 1: Создайте базу знаний
kb_payload = {
    "name": "Техническая документация Clore.ai",
    "description": "документация и руководства по GPU-облачной торговой площадке",
    "language": "Английский",
    "embedding_model": "text-embedding-ada-002",
    "chunk_method": "naive",  # или 'qa', 'table', 'paper', 'book'
}

response = requests.post(
    f"{BASE_URL}/api/v1/knowledgebase",
    headers=headers,
    json=kb_payload
)
kb = response.json()
kb_id = kb["data"]["id"]
print(f"Создана база знаний: {kb_id}")

# Шаг 2: Загрузите документ
pdf_path = Path("technical_manual.pdf")

with open(pdf_path, "rb") as f:
    files = {"file": (pdf_path.name, f, "application/pdf")}
    upload_response = requests.post(
        f"{BASE_URL}/api/v1/document/upload?kb_id={kb_id}",
        headers={"Authorization": f"Bearer {API_KEY}"},
        files=files
    )

doc = upload_response.json()
doc_id = doc["data"]["id"]
print(f"Загружен документ: {doc_id}")

# Шаг 3: Запустите разбор
parse_response = requests.post(
    f"{BASE_URL}/api/v1/document/run",
    headers=headers,
    json={"doc_ids": [doc_id]}
)
print(f"Разбор начат: {parse_response.json()}")
```

***

### Пример 3: Запрос документов через API

```python
import requests
import json

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"
CHAT_ID = "your-chat-assistant-id"  # Из WebUI → Чат

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def ask_ragflow(question, chat_id, session_id=None):
    """Отправьте вопрос в RAGFlow и получите ответ с цитатами."""
    payload = {
        "question": question,
        "stream": False
    }

    if session_id:
        payload["session_id"] = session_id

    response = requests.post(
        f"{BASE_URL}/api/v1/chat/{chat_id}/completion",
        headers=headers,
        json=payload
    )

    result = response.json()
    if result.get("code") == 0:
        data = result["data"]
        answer = data.get("answer", "")
        references = data.get("reference", {}).get("chunks", [])
        return answer, references
    else:
        return None, []

# Примеры запросов
questions = [
    "Какие характеристики GPU доступны на Clore.ai?",
    "Как арендовать GPU-сервер на маркетплейсе?",
    "Какова модель ценообразования для GPU-инстансов?",
    "Какие фреймворки глубокого обучения поддерживаются?",
]

for question in questions:
    print(f"\n📌 В: {question}")
    answer, refs = ask_ragflow(question, CHAT_ID)
    print(f"💬 О: {answer}")
    if refs:
        print(f"📚 Источники ({len(refs)} фрагментов):")
        for ref in refs[:2]:
            print(f"   - {ref.get('docnm_kwd', 'Неизвестно')}: {ref.get('content_ltks', '')[:100]}...")
```

***

### Пример 4: Пакетная обработка документов

```python
import requests
import time
from pathlib import Path

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"

headers = {"Authorization": f"Bearer {API_KEY}"}

def upload_and_parse_documents(kb_id, document_paths):
    """Загрузите несколько документов и дождитесь завершения разбора."""
    doc_ids = []

    # Загрузите все документы
    for doc_path in document_paths:
        path = Path(doc_path)
        with open(path, "rb") as f:
            mime = "application/pdf" if path.suffix == ".pdf" else "text/plain"
            files = {"file": (path.name, f, mime)}
            resp = requests.post(
                f"{BASE_URL}/api/v1/document/upload?kb_id={kb_id}",
                headers=headers,
                files=files
            )
            if resp.status_code == 200:
                doc_id = resp.json()["data"]["id"]
                doc_ids.append(doc_id)
                print(f"✓ Загружено: {path.name} → {doc_id}")
            else:
                print(f"✗ Ошибка: {path.name}")

    # Запустите пакетный разбор
    if doc_ids:
        requests.post(
            f"{BASE_URL}/api/v1/document/run",
            headers={**headers, "Content-Type": "application/json"},
            json={"doc_ids": doc_ids}
        )
        print(f"\nРазбирается {len(doc_ids)} документов...")

        # Опрос до завершения
        while True:
            time.sleep(5)
            status_resp = requests.get(
                f"{BASE_URL}/api/v1/document/list?kb_id={kb_id}",
                headers=headers
            )
            docs = status_resp.json().get("data", {}).get("docs", [])
            pending = [d for d in docs if d.get("status") == "1"]  # 1 = в обработке
            done = [d for d in docs if d.get("status") == "2"]     # 2 = завершено

            print(f"  В обработке: {len(pending)} | Готово: {len(done)}/{len(doc_ids)}")

            if len(pending) == 0:
                break

    print("✓ Все документы разобраны!")
    return doc_ids

# Использование
docs = ["manual_v1.pdf", "faq.txt", "api_reference.pdf"]
doc_ids = upload_and_parse_documents(kb_id="your-kb-id", document_paths=docs)
```

***

### Пример 5: RAGFlow с локальной LLM Ollama

```bash
# 1. Установите Ollama на том же сервере Clore.ai
curl -fsSL https://ollama.ai/install.sh | sh

# 2. Скачайте локальную модель
ollama pull llama3:8b
ollama pull nomic-embed-text  # Для эмбеддингов

# 3. Настройте RAGFlow на использование Ollama
# В WebUI: Настройки → Поставщики моделей → Добавить Ollama
# Base URL: http://host.docker.internal:11434
# Или если Ollama запущен в Docker: http://ollama:11434
```

```python
# Проверьте интеграцию Ollama
import requests

# Убедитесь, что Ollama запущена
resp = requests.get("http://localhost:11434/api/tags")
models = [m["name"] for m in resp.json()["models"]]
print(f"Доступные модели Ollama: {models}")

# Запрос к RAGFlow с использованием локальной LLM (настроенной в WebUI)
BASE_URL = "http://localhost:9380"
API_KEY = "your-api-key"
CHAT_ID = "your-chat-id"

response = requests.post(
    f"{BASE_URL}/api/v1/chat/{CHAT_ID}/completion",
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={"question": "Объясните архитектуру RAGFlow", "stream": False}
)
print(response.json()["data"]["answer"])
```

***

## Конфигурация

### Основные сервисы docker-compose.yml

```yaml
services:
  ragflow:
    image: infiniflow/ragflow:latest
    ports:
      - "9380:9380"
      - "80:80"
    environment:
      - HF_ENDPOINT=https://huggingface.co
      - MACOS=0
    depends_on:
      - mysql
      - minio
      - es01
      - redis

  es01:
    image: elasticsearch:8.11.3
    environment:
      - xpack.security.enabled=false
      - discovery.type=single-node
    volumes:
      - esdata01:/usr/share/elasticsearch/data

  mysql:
    image: mysql:8.0.39
    environment:
      - MYSQL_ROOT_PASSWORD=infini_rag_flow

  minio:
    image: quay.io/minio/minio:RELEASE.2023-12-20T01-00-02Z
    command: server /data --console-address ":9001"

  redis:
    image: redis:7.2.4
```

### Стратегии разбиения на фрагменты

| Метод    | Лучше всего для              | Описание                                       |
| -------- | ---------------------------- | ---------------------------------------------- |
| `naive`  | Общие документы              | Фрагменты фиксированного размера с перекрытием |
| `qa`     | Документы FAQ/вопрос-ответ   | Разбивает на пары вопрос-ответ                 |
| `table`  | Таблицы, электронные таблицы | Сохраняет структуру таблицы                    |
| `paper`  | Научные статьи               | Разделы, аннотация, список литературы          |
| `book`   | Длинные книги, руководства   | Разбиение с учётом глав                        |
| `laws`   | Юридические документы        | Разбиение по статьям                           |
| `manual` | Технические руководства      | Сохранение иерархии разделов                   |

***

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

### 1. Увеличьте память Elasticsearch

```yaml
# В docker-compose.yml
es01:
  environment:
    - ES_JAVA_OPTS=-Xms4g -Xmx4g  # Увеличьте для больших наборов документов
```

### 2. Эмбеддинги с ускорением на GPU

Настройте RAGFlow на использование модели эмбеддингов на базе GPU:

* В Настройки → Поставщики моделей используйте локальную GPU-модель через Ollama
* Или укажите отдельный сервис эмбеддингов, работающий на GPU Clore.ai

### 3. Параллельная обработка документов

RAGFlow по умолчанию обрабатывает документы параллельно. Настройте число воркеров:

```env
# В docker/.env
TASK_WORKER_COUNT=4  # Настройте в зависимости от числа ядер CPU
```

### 4. MinIO для больших наборов документов

Для развёртываний с тысячами документов настройте выделенное хранилище MinIO с большим объёмом диска в вашем заказе CLORE.AI.

***

## Устранение неполадок

### Проблема: сервисы не запускаются (память)

```bash
# Проверьте использование памяти
free -h
docker stats

# Уменьшите память Elasticsearch
# Измените docker/.env: ES_JAVA_OPTS=-Xms1g -Xmx1g
```

### Проблема: не удаётся открыть WebUI на порту 80

```bash
# Проверьте, что nginx запущен
docker compose ps

# Проверьте привязку порта
docker port ragflow-nginx-1

# Проверьте в CLORE.AI: порт 80 должен быть проброшен в вашем заказе сервера
```

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

```bash
# Проверьте логи worker-задачи
docker compose logs ragflow-worker

# Перезапустите worker
docker compose restart ragflow-worker
```

### Проблема: нехватка heap-памяти Elasticsearch

```bash
# Увеличьте heap в .env
ES_JAVA_OPTS=-Xms2g -Xmx2g
docker compose restart es01
```

### Проблема: модель эмбеддингов не найдена

```bash
# Проверьте загрузку модели HuggingFace
docker exec ragflow-server ls /ragflow/models/

# Скачайте повторно
docker exec ragflow-server python -c "
from huggingface_hub import snapshot_download
snapshot_download('BAAI/bge-large-en-v1.5')
"
```

***

## Ссылки

* **GitHub**: <https://github.com/infiniflow/ragflow>
* **Официальная документация**: <https://ragflow.io/docs>
* **Docker Hub**: <https://hub.docker.com/r/infiniflow/ragflow>
* **Справочник API**: <https://ragflow.io/docs/dev/http_api_reference>
* **Discord**: <https://discord.gg/4XxujFgUN7>
* **маркетплейс CLORE.AI**: <https://clore.ai/marketplace>

***

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

| Сценарий использования                                  | Рекомендуемый GPU | Оценочная стоимость на Clore.ai |
| ------------------------------------------------------- | ----------------- | ------------------------------- |
| Разработка/тестирование                                 | RTX 3090 (24 ГБ)  | $0.07–0.21/гпу/ч                |
| RAG для продакшена                                      | RTX 3090 (24 ГБ)  | $0.07–0.21/гпу/ч                |
| Генерация эмбеддингов с высокой пропускной способностью | RTX 4090 (24 ГБ)  | $0.14–0.42/гпу/ч                |

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/rag-i-vektornye-bazy-dannykh/ragflow.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.