RAGFlow

Stelle die RAGFlow-RAG-Engine für tiefes Dokumentenverständnis auf Clore.ai-GPUs bereit

RAGFlow ist eine Open-Source- Retrieval-Augmented-Generation-(RAG)-Engine mit tiefgehenden Funktionen zum Verständnis von Dokumenten. Mit über 50.000 GitHub-Sternen, ist es eine der umfassendsten verfügbaren RAG-Plattformen — entwickelt, um komplexe Dokumente wie PDFs, Word-Dateien, Tabellenkalkulationen, Bilder und mehr zu extrahieren, in Chunks zu zerlegen und darüber zu schlussfolgern.

Im Gegensatz zu einfachen RAG-Systemen, die Dokumente naiv in Chunks aufteilen, verwendet RAGFlow ein layoutbewusstes Parsing, um die Dokumentstruktur, Tabellen, Abbildungen und mehrspaltige Layouts zu verstehen. Das führt zu deutlich höherer Abrufpräzision und besserer Antwortqualität.

Wichtige Funktionen:

• 📄 Tiefgehendes Dokumentenverständnis — OCR, Tabellenerkennung, Abbildungserkennung

• 🔍 Mehrere Chunking-Strategien — semantisch, layoutbewusst, feste Größe, Q&A-Stil

• 🤖 LLM-Integration — funktioniert mit OpenAI, Ollama, Anthropic, lokalen Modellen

• 🌐 Voll ausgestattete WebUI — Dokumentenverwaltung per Drag-and-drop

• 🔌 REST-API — integrieren Sie RAGFlow in jede Anwendung

• 📊 Quellenverfolgung — Antworten enthalten Verweise auf Quelldokumente

• 🏗️ Mandantenfähig — Team-Arbeitsbereiche mit Berechtigungssteuerung

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

---

Serveranforderungen

Parameter	Minimum	Empfohlen
GPU	NVIDIA RTX 3080 (10 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	8 GB	16–24 GB
RAM	16 GB	32–64 GB
CPU	8 Kerne	16+ Kerne
Festplatte	50 GB	100–500 GB
Betriebssystem	Ubuntu 20.04+	Ubuntu 22.04
CUDA	11.8+	12.1+
Ports	22, 9380, 80	22, 9380, 80
Docker	Erforderlich	Docker + Docker Compose

RAGFlow führt mehrere Dienste (Elasticsearch, MinIO, MySQL, Redis, Nginx) zusammen mit der Hauptanwendung aus. Stellen Sie sicher, dass genügend RAM (mindestens 16 GB, empfohlen 32 GB) und Speicherplatz vorhanden sind.

---

Schnellbereitstellung auf CLORE.AI

1. Finden Sie einen geeigneten Server

Gehe zu CLORE.AI-Marktplatz und filtern nach:

• VRAM: ≥ 8 GB

• RAM: ≥ 16 GB

• Festplatte: ≥ 50 GB

• GPU: RTX 3090, 4090, A100, H100

2. Konfigurieren Sie Ihre Bereitstellung

Docker-Image:

infiniflow/ragflow:latest

Port-Zuordnungen:

22 → SSH-Zugriff
80   → RAGFlow Web UI (HTTP)
9380 → RAGFlow API

Startbefehl:

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

3. Greifen Sie auf die WebUI zu

http://<your-clore-server-ip>:80

Standard-Zugangsdaten: [e-mail] / admin

---

Schritt-für-Schritt-Einrichtung

Schritt 1: Per SSH auf Ihren Server verbinden

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

Schritt 2: Docker Compose installieren

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

# Prüfen
docker compose version

Schritt 3: RAGFlow-Repository klonen

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

Schritt 4: Umgebung konfigurieren

# Kopieren und bearbeiten Sie die Umgebungsdatei
cp docker/.env.example docker/.env
nano docker/.env

Wichtige Einstellungen, die konfiguriert werden müssen:

# LLM-Konfiguration
OPENAI_API_KEY=ihr-openai-api-schlüssel

# Oder verwenden Sie eine lokale Ollama-Instanz
OLLAMA_BASE_URL=http://localhost:11434

# Speichereinstellungen
MINIO_USER=ragflow
MINIO_PASSWORD=infini_rag_flow

# MySQL-Einstellungen
MYSQL_PASSWORD=infini_rag_flow

# Anwendungsport
HTTP_PORT=80
RAGFLOW_API_PORT=9380

Schritt 5: Wählen Sie die richtige Image-Variante

# Verfügbare Tags prüfen
# Für CUDA 12.8 (RTX 30xx, 40xx, 50xx)
docker pull infiniflow/ragflow:latest

# Für eine bestimmte CUDA-Version
docker pull infiniflow/ragflow:v0.7.0-cuda12.1

Schritt 6: Alle Dienste starten

cd /workspace/ragflow/docker

# Mit GPU-Unterstützung starten
docker compose -f docker-compose.yml up -d

# Start überwachen (dauert 2–5 Minuten)
docker compose logs -f

Warten Sie auf:

ragflow-server | INFO: Anwendungsstart abgeschlossen.

Schritt 7: Administratorkonto erstellen

Öffnen http://<server-ip>:80 und das erste Administratorkonto registrieren.

Schritt 8: LLM-Modell konfigurieren

1. Gehe zu Einstellungen → Modellanbieter

2. Fügen Sie Ihr LLM hinzu (OpenAI, Ollama usw.)

3. Legen Sie das Standard-Chatmodell und das Embedding-Modell fest

---

Anwendungsbeispiele

Beispiel 1: Dokumente über die WebUI hochladen und abfragen

1. Melde dich an bei http://<server-ip>:80

2. Klicken Sie auf "Wissensdatenbank" → "Wissensdatenbank erstellen"

3. Benennen Sie es: "Clore.ai-Dokumentation"

4. Laden Sie PDF-/Word-/TXT-Dateien per Drag-and-drop hoch

5. Warten Sie auf das Parsing (Fortschritt wird in der UI angezeigt)

6. Gehe zu "Chat" → Erstellen Sie einen neuen Assistenten, der mit Ihrer Wissensdatenbank verknüpft ist

7. Stellen Sie Fragen zu Ihren Dokumenten

---

Beispiel 2: API — Wissensdatenbank erstellen und Dokumente hochladen

import requests
import json
from pathlib import Path

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"  # Erhalten Sie ihn über Einstellungen → API

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

# Schritt 1: Eine Wissensdatenbank erstellen
kb_payload = {
    "name": "Clore.ai Technical Docs",
    "description": "Dokumentation und Leitfäden für GPU-Cloud-Marktplatz",
    "language": "English",
    "embedding_model": "text-embedding-ada-002",
    "chunk_method": "naive",  # oder '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"Wissensdatenbank erstellt: {kb_id}")

# Schritt 2: Ein Dokument hochladen
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"Dokument hochgeladen: {doc_id}")

# Schritt 3: Parsing starten
parse_response = requests.post(
    f"{BASE_URL}/api/v1/document/run",
    headers=headers,
    json={"doc_ids": [doc_id]}
)
print(f"Parsing gestartet: {parse_response.json()}")

---

Beispiel 3: Dokumente per API abfragen

import requests
import json

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"
CHAT_ID = "your-chat-assistant-id"  # Aus der WebUI → Chat

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

def ask_ragflow(question, chat_id, session_id=None):
    """Senden Sie RAGFlow eine Frage und erhalten Sie eine Antwort mit Zitaten."""
    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, []

# Beispielabfragen
questions = [
    "Welche GPU-Spezifikationen sind auf Clore.ai verfügbar?",
    "Wie miete ich einen GPU-Server im Marktplatz?",
    "Wie lautet das Preismodell für GPU-Instanzen?",
    "Welche Deep-Learning-Frameworks werden unterstützt?",
]

for question in questions:
    print(f"\n📌 F: {question}")
    answer, refs = ask_ragflow(question, CHAT_ID)
    print(f"💬 A: {answer}")
    if refs:
        print(f"📚 Quellen ({len(refs)} Chunks):")
        for ref in refs[:2]:
            print(f"   - {ref.get('docnm_kwd', 'Unknown')}: {ref.get('content_ltks', '')[:100]}...")

---

Beispiel 4: Batch-Dokumentverarbeitungspipeline

import requests
import time
from pathlib import Path

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"

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

def upload_and_parse_documents(kb_id, document_paths):
    """Mehrere Dokumente hochladen und auf den Abschluss des Parsings warten."""
    doc_ids = []

    # Alle Dokumente hochladen
    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"✓ Hochgeladen: {path.name} → {doc_id}")
            else:
                print(f"✗ Fehlgeschlagen: {path.name}")

    # Batch-Parsing starten
    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"\nEs werden {len(doc_ids)} Dokumente geparst...")

        # Bis zum Abschluss abfragen
        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 = in Bearbeitung
            done = [d for d in docs if d.get("status") == "2"]     # 2 = abgeschlossen

            print(f"  In Bearbeitung: {len(pending)} | Fertig: {len(done)}/{len(doc_ids)}")

            if len(pending) == 0:
                break

    print("✓ Alle Dokumente geparst!")
    return doc_ids

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

---

Beispiel 5: RAGFlow mit lokalem Ollama-LLM

# 1. Installieren Sie Ollama auf demselben Clore.ai-Server
curl -fsSL https://ollama.ai/install.sh | sh

# 2. Laden Sie ein lokales Modell herunter
ollama pull llama3:8b
ollama pull nomic-embed-text  # Für Embeddings

# 3. RAGFlow für die Verwendung von Ollama konfigurieren
# In der WebUI: Einstellungen → Modellanbieter → Ollama hinzufügen
# Base URL: http://host.docker.internal:11434
# Oder wenn Ollama in Docker läuft: http://ollama:11434

# Ollama-Integration testen
import requests

# Überprüfe, ob Ollama läuft
resp = requests.get("http://localhost:11434/api/tags")
models = [m["name"] for m in resp.json()["models"]]
print(f"Verfügbare Ollama-Modelle: {models}")

# RAGFlow mit lokalem LLM abfragen (in der WebUI konfiguriert)
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": "Erklären Sie die RAGFlow-Architektur", "stream": False}
)
print(response.json()["data"]["answer"])

---

Konfiguration

Wichtige Dienste in 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

Chunking-Strategien

Methode	Am besten geeignet für	Beschreibung
naive	Allgemeine Dokumente	Chunks fester Größe mit Überlappung
qa	FAQ-/Q&A-Dokumente	Teilt anhand von Frage-Antwort-Paaren auf
table	Tabellenkalkulationen, Tabellen	Bewahrt die Tabellenstruktur
paper	Wissenschaftliche Arbeiten	Abschnitte, Zusammenfassung, Referenzen
book	Lange Bücher, Handbücher	Kapitelbewusstes Chunking
laws	Rechtsdokumente	Artikelbasiertes Chunking
manual	Technische Handbücher	Bewahrung der Abschnittshierarchie

---

Leistungstipps

1. Elasticsearch-Speicher skalieren

# In docker-compose.yml
es01:
  environment:
    - ES_JAVA_OPTS=-Xms4g -Xmx4g  # Für große Dokumentensätze erhöhen

2. GPU-beschleunigtes Embedding

Konfigurieren Sie RAGFlow so, dass ein GPU-basiertes Embedding-Modell verwendet wird:

• In Einstellungen → Modellanbieter ein lokales GPU-Modell über Ollama verwenden

• Oder auf einen dedizierten Embedding-Dienst verweisen, der auf der Clore.ai-GPU läuft

3. Parallele Dokumentenverarbeitung

RAGFlow verarbeitet Dokumente standardmäßig parallel. Konfigurieren Sie die Anzahl der Worker:

# In docker/.env
TASK_WORKER_COUNT=4  # Je nach CPU-Kernen anpassen

4. MinIO für große Dokumentensätze

Für Bereitstellungen mit Tausenden von Dokumenten konfigurieren Sie in Ihrer CLORE.AI-Bestellung einen dedizierten MinIO-Speicher mit größerer Speicherzuweisung.

---

Fehlerbehebung

Problem: Dienste starten nicht (Speicher)

# Speichernutzung prüfen
free -h
docker stats

# Elasticsearch-Speicher reduzieren
# docker/.env bearbeiten: ES_JAVA_OPTS=-Xms1g -Xmx1g

Problem: Zugriff auf WebUI über Port 80 nicht möglich

# Prüfen, ob nginx läuft
docker compose ps

# Port-Zuordnung prüfen
docker port ragflow-nginx-1

# In CLORE.AI prüfen: Port 80 muss in Ihrer Server-Bestellung zugeordnet sein

Problem: Dokumenten-Parsing bleibt hängen

# Task-Worker-Logs prüfen
docker compose logs ragflow-worker

# Worker neu starten
docker compose restart ragflow-worker

Problem: Elasticsearch-Heap nicht genügend Speicher

# Heap in .env erhöhen
ES_JAVA_OPTS=-Xms2g -Xmx2g
docker compose restart es01

Problem: Embedding-Modell nicht gefunden

# HuggingFace-Modell-Download prüfen
docker exec ragflow-server ls /ragflow/models/

# Erneut herunterladen
docker exec ragflow-server python -c "
from huggingface_hub import snapshot_download
snapshot_download('BAAI/bge-large-en-v1.5')
"

---

Links

• GitHub: https://github.com/infiniflow/ragflow

• Offizielle Dokumentation: https://ragflow.io/docs

• Docker Hub: https://hub.docker.com/r/infiniflow/ragflow

• API-Referenz: https://ragflow.io/docs/dev/http_api_reference

• Discord: https://discord.gg/4XxujFgUN7

• CLORE.AI-Marktplatz: https://clore.ai/marketplace

---

GPU-Empfehlungen für Clore.ai

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
Entwicklung/Testen	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
RAG in der Produktion	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Embedding mit hohem Durchsatz	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.