RAGFlow

Despliega RAGFlow, motor RAG para comprensión profunda de documentos en las GPU de Clore.ai

RAGFlow es un código abierto motor de Generación Aumentada por Recuperación (RAG) con capacidades profundas de comprensión de documentos. Con más de 50.000 estrellas en GitHub, es una de las plataformas RAG más completas disponibles: diseñada para extraer, segmentar y razonar sobre documentos complejos, incluidos PDFs, archivos Word, hojas de cálculo, imágenes y más.

A diferencia de los sistemas RAG básicos que dividen los documentos en fragmentos de forma ingenua, RAGFlow utiliza análisis con conocimiento del diseño para entender la estructura del documento, tablas, figuras y diseños de múltiples columnas. Esto resulta en una precisión de recuperación y calidad de respuesta dramáticamente superiores.

Características clave:

• 📄 Comprensión profunda de documentos — OCR, extracción de tablas, reconocimiento de figuras

• 🔍 Múltiples estrategias de segmentación — semántica, con conocimiento del diseño, tamaño fijo, estilo Q&A

• 🤖 Integración de LLM — funciona con OpenAI, Ollama, Anthropic, modelos locales

• 🌐 Interfaz Web completa — gestión de documentos con arrastrar y soltar

• 🔌 API REST — integra RAGFlow en cualquier aplicación

• 📊 Seguimiento de citas — las respuestas incluyen referencias al documento fuente

• 🏗️ Multiinquilino — espacios de trabajo de equipo con control de permisos

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

---

Requisitos del servidor

Parámetro	Mínimo	Recomendado
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 núcleos	16+ núcleos
Disco	50 GB	100–500 GB
SO	Ubuntu 20.04+	Ubuntu 22.04
CUDA	11.8+	12.1+
Puertos	22, 9380, 80	22, 9380, 80
Docker	Requerido	Docker + Docker Compose

RAGFlow ejecuta múltiples servicios (Elasticsearch, MinIO, MySQL, Redis, Nginx) junto con la aplicación principal. Asegúrese de tener suficiente RAM (16 GB mínimo, 32 GB recomendado) y espacio en disco.

---

Despliegue rápido en CLORE.AI

1. Encuentra un servidor adecuado

Ve a CLORE.AI Marketplace y filtra por:

• VRAM: ≥ 8 GB

• RAM: ≥ 16 GB

• Disco: ≥ 50 GB

• GPU: RTX 3090, 4090, A100, H100

2. Configura tu despliegue

Imagen Docker:

infiniflow/ragflow:latest

Mapeo de puertos:

22   → acceso SSH
80   → Interfaz Web de RAGFlow (HTTP)
9380 → API de RAGFlow

Comando de inicio:

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

3. Acceda a la WebUI

http://<la-ip-de-tu-servidor-clore>:80

Credenciales por defecto: [email protected] / admin

---

Configuración paso a paso

Paso 1: Conéctate por SSH a tu servidor

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

Paso 2: Instalar Docker Compose

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

# Verificar
docker compose version

Paso 3: Clonar el repositorio de RAGFlow

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

Paso 4: Configurar el entorno

# Copiar y editar el archivo de entorno
cp docker/.env.example docker/.env
nano docker/.env

Configuraciones clave para configurar:

# Configuración de LLM
OPENAI_API_KEY=tu-clave-api-openai

# O use una instancia local de Ollama
OLLAMA_BASE_URL=http://localhost:11434

# Configuración de almacenamiento
MINIO_USER=ragflow
MINIO_PASSWORD=infini_rag_flow

# Configuración de MySQL
MYSQL_PASSWORD=infini_rag_flow

# Puerto de la aplicación
HTTP_PORT=80
RAGFLOW_API_PORT=9380

Paso 5: Elegir la variante de imagen correcta

# Comprobar etiquetas disponibles
# Para CUDA 12.1 (la mayoría de tarjetas RTX)
docker pull infiniflow/ragflow:latest

# Para versión específica de CUDA
docker pull infiniflow/ragflow:v0.7.0-cuda12.1

Paso 6: Iniciar todos los servicios

cd /workspace/ragflow/docker

# Iniciar con soporte GPU
docker compose -f docker-compose.yml up -d

# Monitorizar el inicio (toma 2-5 minutos)
docker compose logs -f

Espere a:

ragflow-server | INFO: Application startup complete.

Paso 7: Crear cuenta de administrador

Abierto http://<ip-del-servidor>:80 y registre la primera cuenta de administrador.

Paso 8: Configurar el modelo LLM

1. Ve a Ajustes → Proveedores de modelo

2. Agregue su LLM (OpenAI, Ollama, etc.)

3. Establezca el modelo de chat predeterminado y el modelo de embeddings

---

Ejemplos de uso

Ejemplo 1: Cargar y consultar documentos vía WebUI

1. Inicia sesión en http://<ip-del-servidor>:80

2. Haz clic "Base de conocimiento" → "Crear base de conocimiento"

3. Nómbralo: "Documentación de Clore.ai"

4. Suba archivos PDF/Word/TXT usando arrastrar y soltar

5. Espere el parseo (progreso mostrado en la UI)

6. Ve a "Chat" → Cree un nuevo asistente vinculado a su base de conocimiento

7. Haga preguntas sobre sus documentos

---

Ejemplo 2: API — Crear base de conocimiento y subir documentos

import requests
import json
from pathlib import Path

BASE_URL = "http://<la-ip-de-tu-servidor-clore>:9380"
API_KEY = "tu-clave-api-ragflow"  # Obtenga en Ajustes → API

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

# Paso 1: Crear una base de conocimiento
kb_payload = {
    "name": "Documentos Técnicos de Clore.ai",
    "description": "Documentación y guías del mercado de GPU en la nube",
    "language": "English",
    "embedding_model": "text-embedding-ada-002",
    "chunk_method": "naive",  # o '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"Created knowledge base: {kb_id}")

# Paso 2: Subir un documento
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"Uploaded document: {doc_id}")

# Paso 3: Comenzar el parseo
parse_response = requests.post(
    f"{BASE_URL}/api/v1/document/run",
    headers=headers,
    json={"doc_ids": [doc_id]}
)
print(f"Parsing started: {parse_response.json()}")

---

Ejemplo 3: Consultar documentos vía API

import requests
import json

BASE_URL = "http://<la-ip-de-tu-servidor-clore>:9380"
API_KEY = "tu-clave-api-ragflow"
CHAT_ID = "tu-id-de-asistente-de-chat"  # Desde WebUI → Chat

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

def ask_ragflow(question, chat_id, session_id=None):
    """Enviar una pregunta a RAGFlow y obtener una respuesta con citas."""
    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, []

# Consultas de ejemplo
questions = [
    "¿Cuáles son las especificaciones de GPU disponibles en Clore.ai?",
    "¿Cómo alquilo un servidor GPU en el mercado?",
    "¿Cuál es el modelo de precios para las instancias GPU?",
    "¿Qué frameworks de deep learning son compatibles?",
]

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

---

Ejemplo 4: Canalización de procesamiento por lotes de documentos

import requests
import time
from pathlib import Path

BASE_URL = "http://<la-ip-de-tu-servidor-clore>:9380"
API_KEY = "tu-clave-api-ragflow"

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

def upload_and_parse_documents(kb_id, document_paths):
    """Subir múltiples documentos y esperar a que el parseo se complete."""
    doc_ids = []

    # Subir todos los documentos
    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"✓ Subido: {path.name} → {doc_id}")
            else:
                print(f"✗ Fallido: {path.name}")

    # Iniciar parseo por lotes
    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"\nParseando {len(doc_ids)} documentos...")

        # Sondear hasta completar
        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 = procesando
            done = [d for d in docs if d.get("status") == "2"]     # 2 = completado

            print(f"  Procesando: {len(pending)} | Completado: {len(done)}/{len(doc_ids)}")

            if len(pending) == 0:
                break

    print("✓ ¡Todos los documentos parseados!")
    return doc_ids

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

---

Ejemplo 5: RAGFlow con LLM Ollama local

# 1. Instale Ollama en el mismo servidor Clore.ai
curl -fsSL https://ollama.ai/install.sh | sh

# 2. Descargue un modelo local
ollama pull llama3:8b
ollama pull nomic-embed-text  # Para embeddings

# 3. Configure RAGFlow para usar Ollama
# En WebUI: Ajustes → Proveedores de modelo → Añadir Ollama
# URL base: http://host.docker.internal:11434
# O si Ollama se ejecuta en Docker: http://ollama:11434

# Probar integración de Ollama
import requests

# Verificar que Ollama esté en ejecución
resp = requests.get("http://localhost:11434/api/tags")
models = [m["name"] for m in resp.json()["models"]]
print(f"Modelos Ollama disponibles: {models}")

# Consultar RAGFlow usando LLM local (configurado en WebUI)
BASE_URL = "http://localhost:9380"
API_KEY = "tu-clave-api"
CHAT_ID = "tu-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": "Explica la arquitectura de RAGFlow", "stream": False}
)
print(response.json()["data"]["answer"])

---

Configuración

Servicios clave en 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

Estrategias de segmentación

Método	Mejor para	Descripción
naive	Documentos generales	Fragmentos de tamaño fijo con solapamiento
qa	Documentos FAQ/Preguntas y respuestas	Divide en pares pregunta-respuesta
table	Hojas de cálculo, tablas	Preserva la estructura de la tabla
paper	Artículos académicos	Secciones, resumen, referencias
book	Libros largos, manuales	Segmentación con conciencia de capítulos
laws	Documentos legales	Segmentación por artículos
manual	Manuales técnicos	Preservación de la jerarquía de secciones

---

Consejos de rendimiento

1. Escalar la memoria de Elasticsearch

# En docker-compose.yml
es01:
  environment:
    - ES_JAVA_OPTS=-Xms4g -Xmx4g  # Aumentar para conjuntos grandes de documentos

2. Embedding acelerado por GPU

Configure RAGFlow para usar un modelo de embeddings basado en GPU:

• En Ajustes → Proveedores de modelo, use un modelo GPU local vía Ollama

• O apunte a un servicio de embeddings dedicado ejecutándose en la GPU de Clore.ai

3. Procesamiento paralelo de documentos

RAGFlow procesa documentos en paralelo por defecto. Configure el número de workers:

# En docker/.env
TASK_WORKER_COUNT=4  # Ajuste según núcleos de CPU

4. MinIO para grandes conjuntos de documentos

Para despliegues con miles de documentos, configure almacenamiento MinIO dedicado con mayor asignación de disco en su pedido de CLORE.AI.

---

Solución de problemas

Problema: Los servicios no arrancan (memoria)

# Comprobar uso de memoria
free -h
docker stats

# Reducir memoria de Elasticsearch
# Edite docker/.env: ES_JAVA_OPTS=-Xms1g -Xmx1g

Problema: No se puede acceder a la WebUI en el puerto 80

# Comprobar que nginx esté en ejecución
docker compose ps

# Comprobar el enlace del puerto
docker port ragflow-nginx-1

# Verificar en CLORE.AI: el puerto 80 debe estar mapeado en su orden de servidor

Problema: Parseo de documento atascado

# Comprobar logs del worker de tareas
docker compose logs ragflow-worker

# Reiniciar worker
docker compose restart ragflow-worker

Problema: Heap de Elasticsearch sin memoria

# Incrementar heap en .env
ES_JAVA_OPTS=-Xms2g -Xmx2g
docker compose restart es01

Problema: Modelo de embeddings no encontrado

# Verificar descarga del modelo en HuggingFace
docker exec ragflow-server ls /ragflow/models/

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

---

Enlaces

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

• Documentación oficial: https://ragflow.io/docs

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

• Referencia de la API: https://ragflow.io/docs/dev/http_api_reference

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

• CLORE.AI Marketplace: https://clore.ai/marketplace

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
RAG en producción	RTX 3090 (24GB)	~$0.12/gpu/hr
Embeddings de alto rendimiento	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.