RAGFlow

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

RAGFlow es un motor de código abierto 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, dividir en fragmentos y razonar sobre documentos complejos, incluidos PDF, archivos de Word, hojas de cálculo, imágenes y más.

A diferencia de los sistemas RAG básicos que dividen ingenuamente los documentos en fragmentos, RAGFlow usa un análisis consciente del diseño para comprender la estructura del documento, tablas, figuras y diseños de varias columnas. Esto da como resultado una precisión de recuperación y una calidad de respuesta significativamente mayores.

Características principales:

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

• 🔍 Múltiples estrategias de fragmentación — semántica, consciente del diseño, tamaño fijo, estilo preguntas y respuestas

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

• 🌐 WebUI con todas las funciones — gestión de documentos mediante 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 en equipo con control de permisos

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

---

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 varios servicios (Elasticsearch, MinIO, MySQL, Redis, Nginx) junto con la aplicación principal. Asegúrate de tener suficiente RAM (16 GB como mínimo, 32 GB recomendados) y espacio en disco.

---

Despliegue rápido en CLORE.AI

1. Encuentra un servidor adecuado

Ve a Marketplace de CLORE.AI y filtra por:

• VRAM: ≥ 8 GB

• RAM: ≥ 16 GB

• Disco: ≥ 50 GB

• GPU: RTX 3090, 4090, A100, H100

2. Configura tu despliegue

Imagen de Docker:

infiniflow/ragflow:latest

Mapeos 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. Acceder a la WebUI

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

Credenciales predeterminadas: [e-mail] / admin

---

Configuración paso a paso

Paso 1: conéctate por SSH a tu servidor

ssh root@<la-ip-de-tu-servidor-clore> -p <puerto-ssh>

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

Ajustes clave para configurar:

# Configuración de LLM
OPENAI_API_KEY=your-openai-api-key

# O usar 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 adecuada

# Revisar las etiquetas disponibles
# Para CUDA 12.8 (RTX 30xx, 40xx, 50xx)
docker pull infiniflow/ragflow:latest

# Para una 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

# Supervisar el inicio (tarda 2-5 minutos)
docker compose logs -f

Espera:

ragflow-server | INFO: inicio de la aplicación completado.

Paso 7: Crear cuenta de administrador

Abre http://<server-ip>:80 y registra la primera cuenta de administrador.

Paso 8: Configurar el modelo LLM

1. Ve a Configuración → Proveedores de modelos

2. Añade tu LLM (OpenAI, Ollama, etc.)

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

---

Ejemplos de uso

Ejemplo 1: Cargar y consultar documentos mediante WebUI

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

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

3. Ponle el nombre: "Documentación de Clore.ai"

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

5. Espera a que se analice (el progreso se muestra en la interfaz)

6. Ve a "Chat" → Crea un nuevo asistente vinculado a tu base de conocimiento

7. Haz preguntas sobre tus documentos

---

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

import requests
import json
from pathlib import Path

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "tu-clave-api-de-ragflow"  # Obtener desde Configuración → 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 nube GPU",
    "language": "Inglés",
    "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"Base de conocimiento creada: {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"Documento cargado: {doc_id}")

# Paso 3: Iniciar el análisis
parse_response = requests.post(
    f"{BASE_URL}/api/v1/document/run",
    headers=headers,
    json={"doc_ids": [doc_id]}
)
print(f"Análisis iniciado: {parse_response.json()}")

---

Ejemplo 3: Consultar documentos mediante API

import requests
import json

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"
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, []

# Ejemplos de consultas
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 aprendizaje profundo son compatibles?",
]

for question in questions:
    print(f"\n📌 P: {question}")
    answer, refs = ask_ragflow(question, CHAT_ID)
    print(f"💬 R: {answer}")
    if refs:
        print(f"📚 Fuentes ({len(refs)} fragmentos):")
        for ref in refs[:2]:
            print(f"   - {ref.get('docnm_kwd', 'Desconocido')}: {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://<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):
    """Sube múltiples documentos y espera a que finalice el análisis."""
    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"✓ Cargado: {path.name} → {doc_id}")
            else:
                print(f"✗ Error: {path.name}")

    # Iniciar análisis 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"\nAnalizando {len(doc_ids)} documentos...")

        # Verificar periódicamente hasta completarse
        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 procesamiento
            done = [d for d in docs if d.get("status") == "2"]     # 2 = completado

            print(f"  En procesamiento: {len(pending)} | Completados: {len(done)}/{len(doc_ids)}")

            if len(pending) == 0:
                break

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

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

---

Ejemplo 5: RAGFlow con LLM local de Ollama

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

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

# 3. Configura RAGFlow para usar Ollama
# En la WebUI: Configuración → Proveedores de modelos → Añadir Ollama
# URL base: http://host.docker.internal:11434
# O si Ollama se ejecuta en Docker: http://ollama:11434

# Probar la integración con Ollama
import requests

# Verifica que Ollama se esté ejecutando
resp = requests.get("http://localhost:11434/api/tags")
models = [m["name"] for m in resp.json()["models"]]
print(f"Modelos de Ollama disponibles: {models}")

# Consultar RAGFlow usando un LLM local (configurado en la 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 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

Estrategias de fragmentación

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

---

Consejos de rendimiento

1. Aumentar la memoria de Elasticsearch

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

2. Embeddings acelerados por GPU

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

• En Configuración → Proveedores de modelos, usa un modelo local de GPU a través de Ollama

• O apunta a un servicio de embeddings dedicado que se ejecute en la GPU de Clore.ai

3. Procesamiento paralelo de documentos

RAGFlow procesa documentos en paralelo de forma predeterminada. Configura el número de trabajadores:

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

4. MinIO para conjuntos grandes de documentos

Para implementaciones con miles de documentos, configura almacenamiento MinIO dedicado con una mayor asignación de disco en tu pedido de CLORE.AI.

---

Solución de problemas

Problema: los servicios no arrancan (memoria)

# Comprueba el uso de memoria
free -h
docker stats

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

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

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

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

# Verifica en CLORE.AI: el puerto 80 debe estar mapeado en tu pedido de servidor

Problema: el análisis de documentos se queda atascado

# Revisa los registros del trabajador de tareas
docker compose logs ragflow-worker

# Reiniciar el trabajador
docker compose restart ragflow-worker

Problema: la memoria heap de Elasticsearch se queda sin memoria

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

Problema: no se encuentra el modelo de embeddings

# Verifica la descarga del modelo de 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

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

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
RAG de producción	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Embeddings de alto rendimiento	RTX 4090 (24GB)	$0.14–0.42/gpu/hr

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