# RAGFlow

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](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 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.
{% endhint %}

***

## Despliegue rápido en CLORE.AI

### 1. Encuentra un servidor adecuado

Ve a [CLORE.AI Marketplace](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 Docker:**

```
infiniflow/ragflow:latest
```

**Mapeo 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. Acceda a la WebUI

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

Credenciales por defecto: `admin@ragflow.io` / `admin`

***

## Configuración paso a paso

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

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

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

Configuraciones clave para configurar:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Reiniciar worker
docker compose restart ragflow-worker
```

### Problema: Heap de Elasticsearch sin memoria

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

### Problema: Modelo de embeddings no encontrado

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


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-es/rag-y-bases-de-datos-vectoriales/ragflow.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.