# RAGFlow

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

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

Ключевые особенности:

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

{% 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://<ip-вашего-clore-сервера>:80
```

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

***

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

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

```bash
ssh root@<ip-вашего-clore-сервера> -p <ssh-порт>
```

### Шаг 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.1 (большинство карт RTX)
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: Application startup complete.
```

### Шаг 7: Создайте аккаунт администратора

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

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

1. Перейдите на **Settings → Model Providers**
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://<ip-вашего-clore-сервера>:9380"
API_KEY = "ваш-ragflow-api-key"  # Получите в Settings → API

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

# Шаг 1: Создать базу знаний
kb_payload = {
    "name": "Clore.ai Technical Docs",
    "description": "Документация и руководства по маркетплейсу облачных GPU",
    "language": "English",
    "embedding_model": "text-embedding-ada-002",
    "chunk_method": "naive",  # or '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"Created knowledge base: {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"Uploaded document: {doc_id}")

# Шаг 3: Начать парсинг
parse_response = requests.post(
    f"{BASE_URL}/api/v1/document/run",
    headers=headers,
    json={"doc_ids": [doc_id]}
)
print(f"Parsing started: {parse_response.json()}")
```

***

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

```python
import requests
import json

BASE_URL = "http://<ip-вашего-clore-сервера>:9380"
API_KEY = "your-ragflow-api-key"
CHAT_ID = "your-chat-assistant-id"  # Из WebUI → Chat

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📌 Q: {question}")
    answer, refs = ask_ragflow(question, CHAT_ID)
    print(f"💬 A: {answer}")
    if refs:
        print(f"📚 Источники ({len(refs)} фрагментов):")
        for ref in refs[:2]:
            print(f"   - {ref.get('docnm_kwd', 'Unknown')}: {ref.get('content_ltks', '')[:100]}...")
```

***

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

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

BASE_URL = "http://<ip-вашего-clore-сервера>: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"✓ Uploaded: {path.name} → {doc_id}")
            else:
                print(f"✗ Failed: {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: Settings → Model Providers → Add Ollama
# Базовый 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": "Explain the RAGFlow architecture", "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:

* В Settings → Model Providers используйте локальную 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
# Проверьте логи task worker
docker compose logs ragflow-worker

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

### Проблема: У Elasticsearch закончилась память кучи

```bash
# Увеличьте кучу в .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>

***

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

| Сценарий использования                   | Рекомендуемый GPU | Примерная стоимость на Clore.ai |
| ---------------------------------------- | ----------------- | ------------------------------- |
| Разработка/Тестирование                  | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Production RAG                           | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Высокопропускная способность эмбеддингов | RTX 4090 (24GB)   | \~$0.70/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/rag-i-vektornye-bazy-dannykh/ragflow.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.