> 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 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 {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace). {% endhint %} *** ## 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 | {% hint style="warning" %} 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. {% endhint %} *** ## Déploiement rapide sur CLORE.AI ### 1. Trouvez un serveur adapté Accédez à [la place de marché CLORE.AI](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://:80 ``` Identifiants par défaut : `admin@ragflow.io` / `admin` *** ## Configuration étape par étape ### Étape 1 : connectez-vous en SSH à votre serveur ```bash ssh root@ -p ``` ### É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 modifier le fichier d'environnement cp docker/.env.example docker/.env nano docker/.env ``` Paramètres clés à configurer : ```env # 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 ```bash # 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 ```bash 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://: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://: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 ```python import requests import json from pathlib import Path BASE_URL = "http://: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 ```python import requests import json BASE_URL = "http://: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 ```python import requests import time from pathlib import Path BASE_URL = "http://: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 ```bash # 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 ``` ```python # 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 ```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 | | -------- | ---------------------------- | ------------------------------------------- | | `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 ```yaml # 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 : ```env # 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) ```bash # 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 ```bash # 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 ```bash # 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 ```bash # Augmenter le tas dans .env ES_JAVA_OPTS=-Xms2g -Xmx2g docker compose restart es01 ``` ### Problème : Modèle d'embedding 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**: * **Documentation officielle**: * **Docker Hub**: * **Référence API**: * **Discord**: * **la place de marché CLORE.AI**: *** ## 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](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, 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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/ragflow.md?ask=&goal= ``` `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.