RAGFlow

Déployer RAGFlow, moteur RAG d'analyse approfondie de documents, sur les GPU Clore.ai

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

---

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

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.

---

Déploiement rapide sur CLORE.AI

1. Trouvez un serveur adapté

Aller à 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 -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 : [email protected] / admin

---

Configuration étape par étape

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

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

Étape 2 : Installer Docker Compose

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

# Vérifier
docker compose version

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

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

Étape 4 : Configurer l'environnement

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

Paramètres clés à configurer :

# 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

# 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

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

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

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

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

# 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

# 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

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

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

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

# 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

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

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

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

Problème : Modèle d'embeddings introuvable

# 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 serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.