> 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-es/rag-y-bases-de-datos-vectoriales/ragflow.md).

# 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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

***

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

{% hint style="warning" %}
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.
{% endhint %}

***

## Despliegue rápido en CLORE.AI

### 1. Encuentra un servidor adecuado

Ve a [Marketplace de CLORE.AI](https://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 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
bash -c "docker-compose -f docker/docker-compose.yml up -d"
```

### 3. Acceder a la WebUI

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

Credenciales predeterminadas: `admin@ragflow.io` / `admin`

***

## Configuración paso a paso

### Paso 1: conéctate por SSH a tu servidor

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

### Paso 2: Instalar Docker Compose

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

# Verificar
docker compose version
```

### Paso 3: Clonar el repositorio de RAGFlow

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

### Paso 4: Configurar el entorno

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

Ajustes clave para configurar:

```env
# 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

```bash
# 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

```bash
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

```python
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

```python
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

```python
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

```bash
# 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
```

```python
# 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

```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
```

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

```yaml
# 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:

```env
# 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)

```bash
# 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

```bash
# 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

```bash
# 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

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

### Problema: no se encuentra el modelo de embeddings

```bash
# 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](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# 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-es/rag-y-bases-de-datos-vectoriales/ragflow.md?ask=<question>&goal=<endgoal>
```

`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.