RAGFlow

Déployez le moteur RAG RAGFlow de compréhension approfondie de documents sur les GPU de Clore.ai

RAGFlow est un moteur open source de génération augmentée par récupération (RAG) avec de গভe profondes capacités de compréhension des 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, des fichiers Word, des feuilles de calcul, des images, et plus encore.

Contrairement aux systèmes RAG de base qui découpent naïvement les documents en fragments, RAGFlow utilise une analyse tenant compte de la mise en page pour comprendre la structure des documents, les tableaux, les figures et les dispositions à plusieurs colonnes. Il en résulte une précision de récupération et une qualité de réponse nettement supérieures.

Fonctionnalités clés :

• 📄 Compréhension approfondie des documents — OCR, extraction de tableaux, reconnaissance de figures

• 🔍 Plusieurs stratégies de découpage — sémantique, tenant compte de la mise en page, taille fixe, style Q&R

• 🤖 Intégration LLM — fonctionne avec OpenAI, Ollama, Anthropic, des 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-locataire — espaces de travail d'équipe avec contrôle des autorisations

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

---

Exigences du serveur

Paramètre	Minimum	Recommandé
GPU	NVIDIA RTX 3080 (10 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	8 Go	16–24 Go
RAM	16 Go	32–64 GB
CPU	8 cœurs	16+ cœurs
Disque	50 Go	100–500 Go
Système d'exploitation	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 de disposer de 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é

Accédez à la place de marché CLORE.AI 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://<votre-ip-de-serveur-clore>:80

Identifiants par défaut : [e-mail] / admin

---

Configuration étape par étape

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

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

É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 modifier le fichier d'environnement
cp docker/.env.example docker/.env
nano docker/.env

Paramètres clés à configurer :

# Configuration du LLM
OPENAI_API_KEY=votre-clé-api-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 : Choisissez la bonne variante d'image

# Vérifier les balises disponibles
# Pour CUDA 12.8 (RTX 30xx, 40xx, 50xx)
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 prise en charge du GPU
docker compose -f docker-compose.yml up -d

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

Attendez :

ragflow-server | INFO: Le démarrage de l'application est terminé.

Étape 7 : Créer un compte administrateur

Ouvrez http://<server-ip>:80 et enregistrez le premier compte administrateur.

Étape 8 : Configurer le modèle LLM

1. Accédez à 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'intégration

---

Exemples d'utilisation

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

1. Connectez-vous à http://<server-ip>:80

2. Cliquez sur "Base de connaissances" → "Créer une base de connaissances"

3. Nommez-le : "Documentation Clore.ai"

4. Téléversez des fichiers PDF/Word/TXT en utilisant le glisser-déposer

5. Attendez l'analyse (la progression est affichée dans l'interface)

6. Accédez à "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://<votre-ip-de-serveur-clore>:9380"
API_KEY = "votre-clé-api-ragflow"  # À récupérer 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": "Documentation technique Clore.ai",
    "description": "Documentation et guides du marché 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 : Démarrer l'analyse
parse_response = requests.post(
    f"{BASE_URL}/api/v1/document/run",
    headers=headers,
    json={"doc_ids": [doc_id]}
)
print(f"Analyse démarrée : {parse_response.json()}")

---

Exemple 3 : Interroger des documents via l'API

import requests
import json

BASE_URL = "http://<votre-ip-de-serveur-clore>:9380"
API_KEY = "votre-clé-api-ragflow"
CHAT_ID = "votre-id-d-assistant-de-chat"  # Depuis l'interface Web → 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, []

# Exemples de questions
questions = [
    "Quelles sont les spécifications GPU disponibles sur Clore.ai ?",
    "Comment louer un serveur GPU sur la place de marché ?",
    "Quel est le modèle tarifaire des 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)} fragments) :")
        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://<votre-ip-de-serveur-clore>:9380"
API_KEY = "votre-clé-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 de l'analyse."""
    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 l'analyse 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"\nAnalyse de {len(doc_ids)} documents...")

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

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

            if len(pending) == 0:
                break

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

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

---

Exemple 5 : RAGFlow avec un LLM local Ollama

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

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

# 3. Configurer RAGFlow pour utiliser Ollama
# Dans l'interface Web : Paramètres → Fournisseurs de modèles → Ajouter Ollama
# URL de base : http://host.docker.internal:11434
# Ou si Ollama s'exécute dans Docker : http://ollama:11434

# Tester l'intégration Ollama
import requests

# Vérifiez qu'Ollama est en cours d'exécution
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 le LLM local (configuré dans l'interface Web)
BASE_URL = "http://localhost:9380"
API_KEY = "votre-clé-api"
CHAT_ID = "votre-id-de-chat"

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

Services clés de docker-compose.yml

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
naive	Documents généraux	Fragments de taille fixe avec chevauchement
qa	Documents FAQ/Q&R	Découpe sur les paires question-réponse
table	Feuilles de calcul, tableaux	Préserve la structure des tableaux
paper	Articles académiques	Sections, résumé, références
book	Livres longs, manuels	Découpage tenant compte des chapitres
laws	Documents juridiques	Découpage basé sur les articles
manual	Manuels techniques	Préservation de la hiérarchie des sections

---

Conseils de performance

1. Augmenter la mémoire Elasticsearch

# Dans docker-compose.yml
es01 :
  environment :
    - ES_JAVA_OPTS=-Xms4g -Xmx4g  # Augmenter pour les grands ensembles de documents

2. Intégration des embeddings accélérée par GPU

Configurez RAGFlow pour utiliser un modèle d'embedding basé sur GPU :

• Dans Paramètres → Fournisseurs de modèles, utilisez un modèle GPU local via Ollama

• Ou pointez vers un service d'embedding 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 en fonction des cœurs CPU

4. MinIO pour les grands ensembles de documents

Pour les déploiements comportant 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 parviennent pas à démarrer (mémoire)

# Vérifier l'utilisation de la mémoire
free -h
docker stats

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

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

# Vérifier qu'nginx est en cours d'exécution
docker compose ps

# Vérifier l’association du port
docker port ragflow-nginx-1

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

Problème : Analyse de documents bloquée

# Vérifier les journaux du worker de tâches
docker compose logs ragflow-worker

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

Problème : Le tas Elasticsearch est à court de mémoire

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

Problème : Modèle d'embedding 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

• la place de marché CLORE.AI: https://clore.ai/marketplace

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
RAG de production	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Embeddings à haut débit	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.