# Plataforma RAG AnythingLLM

## Resumen

[AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) es un espacio de trabajo de IA completo y de código abierto con más de 40K estrellas en GitHub. Combina RAG basado en documentos (Generación Aumentada por Recuperación), agentes de IA y un creador de agentes sin código en una sola aplicación autoalojada — todo gestionado a través de una interfaz limpia e intuitiva que no requiere programación para configurarse.

**¿Por qué ejecutar AnythingLLM en Clore.ai?**

* **Pipeline RAG completo listo para usar** — Sube archivos PDF, documentos Word, sitios web y transcripciones de YouTube. AnythingLLM automáticamente los divide en fragmentos, crea embeddings y los almacena para búsqueda semántica.
* **No se requiere GPU para la aplicación** — AnythingLLM utiliza embeddings basados en CPU por defecto. Combínalo con un servidor GPU de Clore.ai que ejecute Ollama o vLLM para inferencia local.
* **Agentes de IA con herramientas reales** — Los agentes integrados pueden navegar por la web, escribir y ejecutar código, gestionar archivos y llamar a APIs externas — todo orquestado mediante una GUI.
* **Compatibilidad con MCP** — Se integra con el ecosistema del Model Context Protocol para conectividad extendida de herramientas.
* **Aislamiento de espacios de trabajo** — Crea espacios de trabajo separados con diferentes bases de conocimiento y configuraciones de LLM para distintos proyectos o equipos.

### Descripción general de la arquitectura

```
┌─────────────────────────────────────────────┐
│            AnythingLLM (Puerto 3001)         │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Docs │  │  Agents  │  │  Users   │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    LLM Provider Router   │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (local)
  Claude        Gemini      vLLM (local)
```

***

## Requisitos

### Especificaciones del servidor

| Componente         | Mínimo            | Recomendado                        | Notas                                                        |
| ------------------ | ----------------- | ---------------------------------- | ------------------------------------------------------------ |
| **GPU**            | Ninguna requerida | RTX 3090 (si se usan LLMs locales) | Solo para backend Ollama/vLLM                                |
| **VRAM**           | —                 | 24 GB                              | Para inferencia de modelos locales                           |
| **CPU**            | 2 vCPU            | 4 vCPU                             | El embedding se ejecuta en CPU                               |
| **RAM**            | 4 GB              | 8 GB                               | Más = índice de documentos más grande en memoria             |
| **Almacenamiento** | 10 GB             | 50+ GB                             | Almacenamiento de documentos, DB vectorial, caché de modelos |

### Referencia de precios de Clore.ai

| Tipo de servidor                 | Costo aprox.   | Caso de uso                               |
| -------------------------------- | -------------- | ----------------------------------------- |
| Instancia CPU (4 vCPU, 8 GB RAM) | \~$0.05–0.10/h | AnythingLLM + proveedores de API externos |
| RTX 3090 (24 GB VRAM)            | \~$0.20/h      | AnythingLLM + LLMs locales Ollama         |
| RTX 4090 (24 GB VRAM)            | \~$0.35/h      | AnythingLLM + inferencia local más rápida |
| A100 80 GB                       | \~$1.10/h      | AnythingLLM + modelos grandes de 70B+     |

> 💡 **Consejo profesional:** El embedding integrado de AnythingLLM (LanceDB + embedder local en CPU) funciona sin GPU. Para el backend LLM, puedes usar proveedores de API con nivel gratuito como OpenRouter o Groq para mantener los costos mínimos.

### Prerrequisitos

* Servidor Clore.ai con acceso SSH
* Docker (preinstalado en los servidores de Clore.ai)
* Al menos una clave API de LLM **o** backend local Ollama/vLLM

***

## Inicio rápido

### Método 1: Contenedor Docker único (Recomendado)

El despliegue oficial en un solo contenedor incluye todo: la interfaz web, la tienda vectorial LanceDB y el procesador de documentos.

**Paso 1: Conéctate a tu servidor Clore.ai**

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

**Paso 2: Configurar el directorio de almacenamiento**

```bash
export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"
```

**Paso 3: Ejecutar AnythingLLM**

```bash
docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v ${STORAGE_LOCATION}:/app/server/storage \
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm
```

> **Por qué `--cap-add SYS_ADMIN`?** AnythingLLM usa Chromium para scraping de páginas web y renderizado de PDF, lo que requiere capacidades elevadas en el contenedor.

**Paso 4: Verificar el inicio**

```bash
docker logs anythingllm --tail 30 -f
# Espera: "Server listening on port 3001"
```

**Paso 5: Completar el asistente de configuración**

Abre en el navegador:

```
http://<tu-ip-servidor-clore>:3001
```

El asistente de configuración inicial te guía a través de:

1. Crear cuenta de administrador
2. Elegir proveedor de LLM
3. Elegir modelo de embedding
4. Configurar tu primer espacio de trabajo

***

### Método 2: Docker Compose (Multi-Servicio)

Para despliegues de producción con servicios separados y gestión más sencilla:

**Paso 1: Crear directorio del proyecto**

```bash
mkdir -p ~/anythingllm && cd ~/anythingllm
mkdir -p storage
touch storage/.env
```

**Paso 2: Crear `docker-compose.yml`**

```bash
cat > docker-compose.yml << 'EOF'
versión: '3.8'

services:
  anythingllm:
    image: mintplexlabs/anythingllm:latest
    container_name: anythingllm
    restart: unless-stopped
    ports:
      - "3001:3001"
    cap_add:
      - SYS_ADMIN
    environment:
      STORAGE_DIR: "/app/server/storage"
      # Proveedor de LLM (configurar uno)
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # Embedding
      EMBEDDING_ENGINE: native
      # Vector DB
      VECTOR_DB: lancedb
      # Autenticación
      AUTH_TOKEN: ${ANYTHINGLLM_AUTH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
    volumes:
      - ./storage:/app/server/storage
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/api/ping"]
      intervalo: 30s
      tiempo de espera: 10s
      reintentos: 3

volumes:
  anythingllm_storage:
EOF
```

**Paso 3: Crear `.env` archivo**

```bash
cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=tu-secreto-aleatorio-de-64-caracteres-aquí
EOF
```

**Paso 4: Iniciar**

```bash
docker compose up -d
docker compose logs anythingllm -f
```

***

### Método 3: Con variables de entorno preconfiguradas

Para despliegue automatizado sin el asistente de configuración:

```bash
export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION && touch "$STORAGE_LOCATION/.env"

docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v ${STORAGE_LOCATION}:/app/server/storage \
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e LLM_PROVIDER=openai \
  -e OPEN_AI_KEY=sk-your-key \
  -e OPEN_MODEL_PREF=gpt-4o-mini \
  -e EMBEDDING_ENGINE=native \
  -e VECTOR_DB=lancedb \
  -e AUTH_TOKEN=your-password \
  -e JWT_SECRET=$(openssl rand -hex 32) \
  mintplexlabs/anythingllm
```

***

## Configuración

### Opciones de proveedor de LLM

AnythingLLM admite una amplia gama de backends LLM. Configúralo en la UI bajo **Settings → LLM Preference**, o vía variables de entorno:

**OpenAI:**

```bash
-e LLM_PROVIDER=openai
-e OPEN_AI_KEY=sk-your-key
-e OPEN_MODEL_PREF=gpt-4o
```

**Anthropic Claude:**

```bash
-e LLM_PROVIDER=anthropic
-e ANTHROPIC_API_KEY=sk-ant-your-key
-e ANTHROPIC_MODEL_PREF=claude-sonnet-4-5
```

**Google Gemini:**

```bash
-e LLM_PROVIDER=gemini
-e GEMINI_API_KEY=your-key
-e GEMINI_LLM_MODEL_PREF=gemini-1.5-pro
```

**Ollama (local):**

```bash
-e LLM_PROVIDER=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e OLLAMA_MODEL_PREF=llama3.2
```

**OpenRouter (acceso a 100+ modelos):**

```bash
-e LLM_PROVIDER=openrouter
-e OPENROUTER_API_KEY=sk-or-your-key
-e OPENROUTER_MODEL_PREF=meta-llama/llama-3.1-8b-instruct:free
```

### Configuración de Embeddings

| Motor     | Backend         | Necesita GPU | Calidad         |
| --------- | --------------- | ------------ | --------------- |
| `native`  | CPU (integrado) | No           | Bueno           |
| `openai`  | API de OpenAI   | No           | Excelente       |
| `ollama`  | Ollama local    | Opcional     | Bueno-Excelente |
| `localai` | LocalAI         | Opcional     | Variable        |

```bash
# Usa embeddings de OpenAI para la mejor calidad
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# Usa embeddings de Ollama para un pipeline totalmente local
-e EMBEDDING_ENGINE=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e EMBEDDING_MODEL_PREF=nomic-embed-text
```

### Opciones de bases de datos vectoriales

| DB         | Descripción                  | Mejor para                                        |
| ---------- | ---------------------------- | ------------------------------------------------- |
| `lancedb`  | Integrado, sin configuración | Por defecto, conjuntos de datos pequeños-medianos |
| `chroma`   | ChromaDB (externa)           | Conjuntos de datos medianos, flexibilidad         |
| `pinecone` | Pinecone en la nube          | Conjuntos de datos grandes, producción            |
| `weaviate` | Weaviate (autoalojado)       | Casos de uso avanzados                            |

### Configuración del espacio de trabajo

Los espacios de trabajo de AnythingLLM son entornos aislados con su propio:

* Base de conocimiento de documentos
* Configuraciones de LLM (pueden anular lo global)
* Historial de chat
* Configuraciones de agentes

Crea espacios de trabajo vía la UI o la API:

```bash
# Crear espacio de trabajo vía API
curl -X POST http://localhost:3001/api/v1/workspace/new \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"name": "My Project", "similarityThreshold": 0.7}'
```

### Ingestión de documentos

Sube documentos mediante la UI o la API:

```bash
# Subir un documento vía API
curl -X POST http://localhost:3001/api/v1/document/upload \
  -H "Authorization: Bearer your-api-key" \
  -F "file=@/ruta/al/documento.pdf"

# Mover documento al espacio de trabajo
curl -X POST http://localhost:3001/api/v1/workspace/my-project/update-embeddings \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"adds": ["custom-documents/document.pdf-chunk-1.json"]}'
```

***

## Aceleración por GPU

AnythingLLM en sí se ejecuta en CPU. La aceleración por GPU se aplica al backend de inferencia LLM.

### Ejecutando Ollama en el mismo servidor Clore.ai

```bash
# Inicia Ollama con soporte GPU
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \
  ollama/ollama

# Descargar modelos para AnythingLLM
docker exec ollama ollama pull llama3.2          # 2B, rápido
docker exec ollama ollama pull llama3.1:8b       # 8B, equilibrado
docker exec ollama ollama pull nomic-embed-text  # para embeddings
docker exec ollama ollama pull mxbai-embed-large # mejores embeddings

# Reiniciar AnythingLLM con la configuración de Ollama
docker stop anythingllm && docker rm anythingllm

docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e LLM_PROVIDER=ollama \
  -e OLLAMA_BASE_PATH=http://172.17.0.1:11434 \
  -e OLLAMA_MODEL_PREF=llama3.1:8b \
  -e EMBEDDING_ENGINE=ollama \
  -e EMBEDDING_MODEL_PREF=nomic-embed-text \
  mintplexlabs/anythingllm
```

### Rendimiento de modelos GPU en Clore.ai

| Modelo        | GPU       | VRAM  | Velocidad de embeddings | Velocidad de inferencia | Costo/hr |
| ------------- | --------- | ----- | ----------------------- | ----------------------- | -------- |
| Llama 3.2 3B  | RTX 3090  | 2 GB  | Rápido                  | 60–80 tok/s             | \~$0.20  |
| Llama 3.1 8B  | RTX 3090  | 6 GB  | Rápido                  | 40–60 tok/s             | \~$0.20  |
| Mistral 7B    | RTX 3090  | 5 GB  | Rápido                  | 45–65 tok/s             | \~$0.20  |
| Llama 3.1 70B | A100 80GB | 40 GB | Medio                   | 20–35 tok/s             | \~$1.10  |

***

## Consejos y mejores prácticas

### Mejores prácticas para ingestión de documentos

```bash
# Para conjuntos grandes de documentos, aumenta la memoria de Node.js
-e NODE_OPTIONS="--max-old-space-size=4096"

# Ajustes de fragmentación recomendados para diferentes tipos de documentos
# Documentación técnica: tamaño de fragmento 1000, solapamiento 200
# Legal/contratos: tamaño de fragmento 500, solapamiento 100
# Libros/artículos: tamaño de fragmento 1500, solapamiento 300
```

* **Preprocesar PDFs grandes** — Las digitalizaciones con mucho OCR ralentizan la ingestión. Usa `pdftotext` o Adobe OCR de antemano.
* **Organizar por espacio de trabajo** — Crea espacios de trabajo separados por proyecto/dominio para una mejor precisión de recuperación.
* **Usar consultas específicas** — RAG funciona mejor con preguntas específicas, no con solicitudes amplias.

### Gestión de costos en Clore.ai

```bash
# Haz una copia de seguridad de tu almacenamiento antes de detener una instancia Clore.ai
tar -czf anythingllm-backup-$(date +%Y%m%d).tar.gz ~/anythingllm/

# Para reanudar en una nueva instancia Clore.ai, restaura la copia de seguridad
tar -xzf anythingllm-backup-20240101.tar.gz -C ~/
```

Dado que las instancias Clore.ai son efímeras, siempre haz copia de seguridad del directorio de almacenamiento. Contiene:

* Embeddings vectoriales (LanceDB)
* Documentos subidos
* Historial de chat
* Configuraciones de agentes

### Configuración multiusuario

```bash
# Habilitar modo multiusuario en la UI:
# Settings → Security → Enable Multi-User Mode

# O vía entorno:
-e MULTI_USER_MODE=true

# Crear usuario vía API después de habilitar multiusuario
curl -X POST http://localhost:3001/api/v1/admin/users/new \
  -H "Authorization: Bearer admin-api-key" \
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "securepass", "role": "default"}'
```

### Configuración de agentes de IA

Los agentes de AnythingLLM pueden realizar tareas del mundo real. Habilita herramientas en **Settings → Agents**:

* **Navegación web** — Recupera y lee páginas web
* **Búsqueda en Google** — Realiza búsquedas en Google (requiere clave API)
* **Intérprete de código** — Ejecuta Python en sandbox
* **GitHub** — Lee repositorios
* **Conector SQL** — Consulta bases de datos

```bash
# Habilitar capacidades de agente vía entorno
-e AGENT_SEARCH_PROVIDER=google
-e AGENT_GSX_GOOGLE_SEARCH_ENGINE_ID=your-cx-id
-e AGENT_GSX_GOOGLE_SEARCH_KEY=your-api-key
```

### Ajuste de rendimiento

```bash
# Para cargas de procesamiento de documentos pesadas
docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  --cpus="4" \
  --memory="8g" \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm
```

### Actualizar AnythingLLM

```bash
# Descargar la imagen más reciente
docker pull mintplexlabs/anythingllm:latest

# Haz copia de seguridad primero
cp -r $HOME/anythingllm $HOME/anythingllm-backup-$(date +%Y%m%d)

# Detener y eliminar el contenedor antiguo (los datos están en el volumen, seguro)
docker stop anythingllm && docker rm anythingllm

# Reiniciar con el mismo comando
docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm
```

***

## Solución de problemas

### El contenedor inicia pero la UI no es accesible

```bash
# Comprueba que el contenedor esté ejecutándose
docker ps | grep anythingllm

# Revisa los logs por errores de inicio
docker logs anythingllm --tail 50

# Verifica el enlace del puerto
ss -tlnp | grep 3001

# Verifica si el servidor Clore.ai tiene el puerto 3001 en el mapeo de puertos
# (añádelo en la configuración de despliegue de Clore.ai)
```

### La subida de documentos falla

```bash
# Comprueba el espacio en disco disponible
df -h

# Inspecciona los logs del procesador de documentos
docker logs anythingllm 2>&1 | grep -i "error\|fail\|upload"

# Verifica que la capacidad SYS_ADMIN esté establecida (requerida para Chromium)
docker inspect anythingllm | grep -A5 CapAdd
```

### Las respuestas RAG son de mala calidad / con alucinaciones

Causas comunes y soluciones:

```bash
# 1. Ajusta el umbral de similitud (más bajo = más documentos recuperados)
# Settings → Workspace → Vector Database → Similarity Threshold: 0.5

# 2. Incrementa los resultados top-K
# Settings → Workspace → Vector Database → Max Context Snippets: 10

# 3. Mejora el tamaño de los fragmentos (reingesta documentos tras cambiar)
# Settings → Workspace → Text Splitter → Chunk Size: 1000, Overlap: 200

# 4. Cambia a un mejor modelo de embeddings
-e EMBEDDING_ENGINE=openai
-e EMBEDDING_MODEL_PREF=text-embedding-3-large
```

### La conexión a Ollama falla desde AnythingLLM

```bash
# Prueba desde el contenedor AnythingLLM
docker exec anythingllm curl -s http://172.17.0.1:11434/api/tags

# Si eso falla, encuentra la IP real del bridge de Docker
ip route | grep docker
# Usa esa IP en OLLAMA_BASE_PATH

# Alternativa: usar networking host
docker run -d \
  --name anythingllm \
  --network host \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e OLLAMA_BASE_PATH=http://localhost:11434 \
  mintplexlabs/anythingllm
```

### Falta de memoria / fallo del contenedor

```bash
# Comprobar uso de memoria
docker stats anythingllm

# Libera memoria reduciendo la caché de LanceDB
# O cambia a una instancia Clore.ai con más RAM

# Reinicia con límites de memoria y swap
docker run -d \
  --name anythingllm \
  --memory=6g \
  --memory-swap=8g \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm
```

***

## Lecturas adicionales

* [Documentación de AnythingLLM](https://docs.anythingllm.com) — instalación completa y referencia de API
* [AnythingLLM en GitHub](https://github.com/Mintplex-Labs/anything-llm) — código fuente, issues, hoja de ruta
* [AnythingLLM en Docker Hub](https://hub.docker.com/r/mintplexlabs/anythingllm) — etiquetas de imagen
* [Ejecutando Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — backend LLM local para AnythingLLM
* [Ejecutando vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — inferencia de alto rendimiento
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — seleccionar el nivel adecuado de Clore.ai
* [Documentación MCP](https://modelcontextprotocol.io) — Model Context Protocol para extender agentes
* [Referencia de la API de AnythingLLM](https://docs.anythingllm.com/api-reference) — API REST para automatización


---

# 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/plataformas-y-agentes-de-ia/anythingllm.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.