> 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-fr/rag-et-bases-de-donnees-vectorielles/ragflow.md).

# RAGFlow

RAGFlow est un **moteur de génération augmenté par récupération (RAG)** avec des capacités d'analyse approfondie de documents. Avec plus de **50 000 étoiles sur GitHub**, c'est l'une des plateformes RAG les plus complètes disponibles — conçue pour extraire, découper et raisonner sur des documents complexes y compris des PDF, fichiers Word, feuilles de calcul, images, et plus encore.

Contrairement aux systèmes RAG basiques qui découpent naïvement les documents en segments, RAGFlow utilise un parsing conscient de la mise en page pour comprendre la structure des documents, les tableaux, les figures et les mises en page en colonnes multiples. Cela se traduit par une précision de récupération et une qualité de réponse nettement supérieures.

Principales fonctionnalités :

* 📄 **Compréhension approfondie des documents** — OCR, extraction de tableaux, reconnaissance de figures
* 🔍 **Plusieurs stratégies de découpage** — sémantique, conscient de la mise en page, taille fixe, style Q\&R
* 🤖 **Intégration LLM** — fonctionne avec OpenAI, Ollama, Anthropic, modèles locaux
* 🌐 **Interface Web complète** — gestion de documents par glisser-déposer
* 🔌 **API REST** — intégrez RAGFlow dans n'importe quelle application
* 📊 **Suivi des citations** — les réponses incluent des références aux documents sources
* 🏗️ **Multi-tenant** — espaces de travail d'équipe avec contrôle des permissions

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

***

## Exigences serveur

| Paramètre | Minimum                 | Recommandé              |
| --------- | ----------------------- | ----------------------- |
| GPU       | NVIDIA RTX 3080 (10 Go) | NVIDIA RTX 4090 (24 Go) |
| VRAM      | 8 Go                    | 16–24 Go                |
| RAM       | 16 Go                   | 32–64 Go                |
| CPU       | 8 cœurs                 | 16+ cœurs               |
| Disque    | 50 Go                   | 100–500 Go              |
| OS        | Ubuntu 20.04+           | Ubuntu 22.04            |
| CUDA      | 11.8+                   | 12.1+                   |
| Ports     | 22, 9380, 80            | 22, 9380, 80            |
| Docker    | Requis                  | Docker + Docker Compose |

{% hint style="warning" %}
RAGFlow exécute plusieurs services (Elasticsearch, MinIO, MySQL, Redis, Nginx) en plus de l'application principale. Assurez-vous d'avoir suffisamment de RAM (16 Go minimum, 32 Go recommandés) et d'espace disque.
{% endhint %}

***

## Déploiement rapide sur CLORE.AI

### 1. Trouvez un serveur adapté

Aller à [CLORE.AI Marketplace](https://clore.ai/marketplace) et filtrez par :

* **VRAM**: ≥ 8 Go
* **RAM** : ≥ 16 Go
* **Disque** : ≥ 50 Go
* **GPU** : RTX 3090, 4090, A100, H100

### 2. Configurez votre déploiement

**Image Docker :**

```
infiniflow/ragflow:latest
```

**Mappages de ports :**

```
22   → Accès SSH
80   → Interface Web RAGFlow (HTTP)
9380 → API RAGFlow
```

**Commande de démarrage :**

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

### 3. Accédez à l'interface Web

```
http://<ip-de-votre-serveur-clore>:80
```

Identifiants par défaut : `admin@ragflow.io` / `admin`

***

## Configuration étape par étape

### Étape 1 : Connectez-vous en SSH à votre serveur

```bash
ssh root@<votre-ip-serveur-clore> -p <port-ssh>
```

### Étape 2 : Installer Docker Compose

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

# Vérifier
docker compose version
```

### Étape 3 : Cloner le dépôt RAGFlow

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

### Étape 4 : Configurer l'environnement

```bash
# Copier et éditer le fichier d'environnement
cp docker/.env.example docker/.env
nano docker/.env
```

Paramètres clés à configurer :

```env
# Configuration LLM
OPENAI_API_KEY=votre-cle-openai

# Ou utilisez une instance Ollama locale
OLLAMA_BASE_URL=http://localhost:11434

# Paramètres de stockage
MINIO_USER=ragflow
MINIO_PASSWORD=infini_rag_flow

# Paramètres MySQL
MYSQL_PASSWORD=infini_rag_flow

# Port de l'application
HTTP_PORT=80
RAGFLOW_API_PORT=9380
```

### Étape 5 : Choisir la variante d'image appropriée

```bash
# Vérifier les tags disponibles
# Pour CUDA 12.1 (la plupart des cartes RTX)
docker pull infiniflow/ragflow:latest

# Pour une version CUDA spécifique
docker pull infiniflow/ragflow:v0.7.0-cuda12.1
```

### Étape 6 : Démarrer tous les services

```bash
cd /workspace/ragflow/docker

# Démarrer avec support GPU
docker compose -f docker-compose.yml up -d

# Surveiller le démarrage (prend 2–5 minutes)
docker compose logs -f
```

Attendez :

```
ragflow-server | INFO: Application startup complete.
```

### Étape 7 : Créer un compte administrateur

Ouvert `http://<ip-du-serveur>:80` et enregistrez le premier compte administrateur.

### Étape 8 : Configurer le modèle LLM

1. Aller à **Paramètres → Fournisseurs de modèles**
2. Ajoutez votre LLM (OpenAI, Ollama, etc.)
3. Définissez le modèle de chat par défaut et le modèle d'embeddings

***

## Exemples d’utilisation

### Exemple 1 : Télécharger et interroger des documents via l'interface Web

1. Connectez-vous à `http://<ip-du-serveur>:80`
2. Cliquez **"Base de connaissances"** → **"Créer une base de connaissances"**
3. Nommez-la : `"Documentation Clore.ai"`
4. Téléversez des fichiers PDF/Word/TXT en glisser-déposer
5. Attendez le parsing (progression affichée dans l'UI)
6. Aller à **"Chat"** → Créez un nouvel assistant lié à votre base de connaissances
7. Posez des questions sur vos documents

***

### Exemple 2 : API — Créer une base de connaissances et téléverser des documents

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

BASE_URL = "http://<ip-de-votre-serveur-clore>:9380"
API_KEY = "votre-cle-api-ragflow"  # Obtenez-la dans Paramètres → API

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

# Étape 1 : Créer une base de connaissances
kb_payload = {
    "name": "Docs techniques Clore.ai",
    "description": "Documentation et guides du marketplace cloud GPU",
    "language": "English",
    "embedding_model": "text-embedding-ada-002",
    "chunk_method": "naive",  # ou '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"Base de connaissances créée : {kb_id}")

# Étape 2 : Téléverser un document
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"Document téléversé : {doc_id}")

# Étape 3 : Lancer le parsing
parse_response = requests.post(
    f"{BASE_URL}/api/v1/document/run",
    headers=headers,
    json={"doc_ids": [doc_id]}
)
print(f"Parsing démarré : {parse_response.json()}")
```

***

### Exemple 3 : Interroger des documents via l'API

```python
import requests
import json

BASE_URL = "http://<ip-de-votre-serveur-clore>:9380"
API_KEY = "votre-cle-api-ragflow"
CHAT_ID = "votre-id-assistant-chat"  # Depuis l'UI → Chat

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

def ask_ragflow(question, chat_id, session_id=None):
    """Envoyer une question à RAGFlow et obtenir une réponse avec citations."""
    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, []

# Requêtes d'exemple
questions = [
    "Quelles sont les spécifications GPU disponibles sur Clore.ai ?",
    "Comment louer un serveur GPU sur le marketplace ?",
    "Quel est le modèle de tarification pour les instances GPU ?",
    "Quels frameworks de deep learning sont pris en charge ?",
]

for question in questions:
    print(f"\n📌 Q : {question}")
    answer, refs = ask_ragflow(question, CHAT_ID)
    print(f"💬 R : {answer}")
    if refs:
        print(f"📚 Sources ({len(refs)} segments) :")
        for ref in refs[:2]:
            print(f"   - {ref.get('docnm_kwd', 'Inconnu')}: {ref.get('content_ltks', '')[:100]}...")
```

***

### Exemple 4 : Pipeline de traitement par lots de documents

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

BASE_URL = "http://<ip-de-votre-serveur-clore>:9380"
API_KEY = "votre-cle-api-ragflow"

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

def upload_and_parse_documents(kb_id, document_paths):
    """Téléverser plusieurs documents et attendre la fin du parsing."""
    doc_ids = []

    # Téléverser tous les documents
    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"✓ Téléversé : {path.name} → {doc_id}")
            else:
                print(f"✗ Échec : {path.name}")

    # Démarrer le parsing par lots
    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"\nParsing de {len(doc_ids)} documents...")

        # Interroger jusqu'à complétion
        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 = en traitement
            done = [d for d in docs if d.get("status") == "2"]     # 2 = terminé

            print(f"  En traitement : {len(pending)} | Terminé : {len(done)}/{len(doc_ids)}")

            if len(pending) == 0:
                break

    print("✓ Tous les documents ont été parsés !")
    return doc_ids

# Utilisation
docs = ["manual_v1.pdf", "faq.txt", "api_reference.pdf"]
doc_ids = upload_and_parse_documents(kb_id="votre-kb-id", document_paths=docs)
```

***

### Exemple 5 : RAGFlow avec LLM Ollama local

```bash
# 1. Installer Ollama sur le même serveur Clore.ai
curl -fsSL https://ollama.ai/install.sh | sh

# 2. Puller un modèle local
ollama pull llama3:8b
ollama pull nomic-embed-text  # Pour les embeddings

# 3. Configurer RAGFlow pour utiliser Ollama
# Dans l'UI : Paramètres → Fournisseurs de modèles → Ajouter Ollama
# URL de base : http://host.docker.internal:11434
# Ou si Ollama tourne en Docker : http://ollama:11434
```

```python
# Tester l'intégration Ollama
import requests

# Vérifier qu'Ollama fonctionne
resp = requests.get("http://localhost:11434/api/tags")
models = [m["name"] for m in resp.json()["models"]]
print(f"Modèles Ollama disponibles : {models}")

# Interroger RAGFlow en utilisant un LLM local (configuré dans l'UI)
BASE_URL = "http://localhost:9380"
API_KEY = "votre-cle-api"
CHAT_ID = "votre-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": "Expliquez l'architecture de RAGFlow", "stream": False}
)
print(response.json()["data"]["answer"])
```

***

## Configuration

### docker-compose.yml Services clés

```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
```

### Stratégies de découpage

| Méthode  | Idéal pour                   | Description                                   |
| -------- | ---------------------------- | --------------------------------------------- |
| `naïf`   | Documents généraux           | Segments de taille fixe avec chevauchement    |
| `qa`     | Documents FAQ/Q\&R           | Découpe basée sur les paires question-réponse |
| `table`  | Feuilles de calcul, tableaux | Conserve la structure du tableau              |
| `paper`  | Articles académiques         | Sections, résumé, références                  |
| `book`   | Livres longs, manuels        | Découpage conscient des chapitres             |
| `laws`   | Documents juridiques         | Découpage par article                         |
| `manual` | Manuels techniques           | Conservation de la hiérarchie des sections    |

***

## Conseils de performance

### 1. Augmenter la mémoire d'Elasticsearch

```yaml
# Dans docker-compose.yml
es01 :
  environment:
    - ES_JAVA_OPTS=-Xms4g -Xmx4g  # Augmenter pour de grands jeux de documents
```

### 2. Embeddings accélérés par GPU

Configurer RAGFlow pour utiliser un modèle d'embeddings basé sur GPU :

* Dans Paramètres → Fournisseurs de modèles, utilisez un modèle GPU local via Ollama
* Ou pointez vers un service d'embeddings dédié exécuté sur le GPU Clore.ai

### 3. Traitement parallèle des documents

RAGFlow traite les documents en parallèle par défaut. Configurez le nombre de workers :

```env
# Dans docker/.env
TASK_WORKER_COUNT=4  # Ajuster selon le nombre de cœurs CPU
```

### 4. MinIO pour les grands jeux de documents

Pour des déploiements avec des milliers de documents, configurez un stockage MinIO dédié avec une allocation de disque plus importante dans votre commande CLORE.AI.

***

## Dépannage

### Problème : Les services ne démarrent pas (mémoire)

```bash
# Vérifier l'utilisation mémoire
free -h
docker stats

# Réduire la mémoire d'Elasticsearch
# Éditer docker/.env : ES_JAVA_OPTS=-Xms1g -Xmx1g
```

### Problème : Impossible d'accéder à l'UI sur le port 80

```bash
# Vérifier que nginx fonctionne
docker compose ps

# Vérifier la liaison de port
docker port ragflow-nginx-1

# Vérifier dans CLORE.AI : le port 80 doit être mappé dans votre commande serveur
```

### Problème : Parsing de document bloqué

```bash
# Vérifier les logs des workers de tâches
docker compose logs ragflow-worker

# Redémarrer le worker
docker compose restart ragflow-worker
```

### Problème : Heap d'Elasticsearch épuisé

```bash
# Augmenter le heap dans .env
ES_JAVA_OPTS=-Xms2g -Xmx2g
docker compose restart es01
```

### Problème : Modèle d'embeddings introuvable

```bash
# Vérifier le téléchargement du modèle HuggingFace
docker exec ragflow-server ls /ragflow/models/

# Retélécharger
docker exec ragflow-server python -c "
from huggingface_hub import snapshot_download
snapshot_download('BAAI/bge-large-en-v1.5')
"
```

***

## Liens

* **GitHub**: <https://github.com/infiniflow/ragflow>
* **Documentation officielle**: <https://ragflow.io/docs>
* **Docker Hub**: <https://hub.docker.com/r/infiniflow/ragflow>
* **Référence API**: <https://ragflow.io/docs/dev/http_api_reference>
* **Discord**: <https://discord.gg/4XxujFgUN7>
* **CLORE.AI Marketplace**: <https://clore.ai/marketplace>

***

## Recommandations GPU Clore.ai

| Cas d’utilisation       | GPU recommandé  | Coût estimé sur Clore.ai |
| ----------------------- | --------------- | ------------------------ |
| Développement/Test      | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| RAG en production       | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| Embeddings à haut débit | RTX 4090 (24GB) | \~$0.70/gpu/hr           |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/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.