Plataforma RAG AnythingLLM

Despliega AnythingLLM en Clore.ai: una plataforma todo en uno para aplicaciones RAG y agentes de IA con chat de documentos integrado, creador de agentes sin código y soporte MCP ejecutándose en servidores de nube GPU rentables.

Descripción general

AnythingLLM es un espacio de trabajo de IA de código abierto y completo con más de 40K estrellas en GitHub. Combina RAG basado en documentos (Generación Aumentada por Recuperación), agentes de IA y un constructor de agentes sin código en una sola aplicación autohospedada — todo gestionado mediante una UI limpia e intuitiva que no requiere programar nada para configurarse.

¿Por qué ejecutar AnythingLLM en Clore.ai?

• Canalización RAG completa lista para usar — Sube PDFs, documentos de Word, sitios web y transcripciones de YouTube. AnythingLLM automáticamente los fragmenta, los incrusta y los almacena para búsqueda semántica.

• No se requiere GPU para la aplicación — AnythingLLM usa incrustación basada en CPU de forma predeterminada. 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, administrar archivos y llamar a APIs externas — todo orquestado a través de una GUI.

• Compatibilidad con MCP — Se integra con el ecosistema del Protocolo de Contexto del Modelo para ampliar la conectividad de herramientas.

• Aislamiento de espacios de trabajo — Crea espacios de trabajo separados con diferentes bases de conocimientos y configuraciones de LLM para distintos proyectos o equipos.

Resumen de la arquitectura

┌─────────────────────────────────────────────┐
│            AnythingLLM (Puerto 3001)        │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Docs │  │ Agentes  │  │ Usuarios │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │ Enrutador del proveedor  │               │
│  │         de LLM           │               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (local)
  Claude        Gemini      vLLM (local)

---

Requisitos

Especificaciones del servidor

Componente	Mínimo	Recomendado	Notas
GPU	No se requiere	RTX 3090 (si se usan LLM locales)	Solo para el backend de Ollama/vLLM
VRAM	—	24 GB	Para la 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, BD vectorial, caché del modelo

Referencia de precios de Clore.ai

Tipo de servidor	Costo aprox.	Caso de uso
Instancia CPU (4 vCPU, 8 GB de RAM)	~$0.05–0.10/h	AnythingLLM + proveedores externos de API
RTX 3090 (24 GB de VRAM)	$0.07–0.21/h	AnythingLLM + LLM locales de Ollama
RTX 4090 (24 GB de VRAM)	$0.14–0.42/h	AnythingLLM + inferencia local más rápida
A100 80 GB	bare metal	AnythingLLM + modelos grandes de 70B+

💡 Consejo: El embedding integrado de AnythingLLM (LanceDB + incrustador local de CPU) funciona sin GPU. Para el backend LLM, puedes usar proveedores de API gratuitos como OpenRouter o Groq para mantener los costos al mínimo.

Requisitos previos

• Servidor de Clore.ai con acceso SSH

• Docker (preinstalado en los servidores de Clore.ai)

• Al menos una clave API de LLM o backend local de Ollama/vLLM

---

Inicio rápido

Método 1: Contenedor Docker único (recomendado)

La implementación oficial en un solo contenedor incluye todo: la interfaz web, el almacén vectorial LanceDB y el procesador de documentos.

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

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

Paso 2: Configura el directorio de almacenamiento

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

Paso 3: Ejecuta AnythingLLM

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 el scraping de páginas web y la renderización de PDF, lo que requiere capacidades elevadas del contenedor.

Paso 4: Verifica el inicio

docker logs anythingllm --tail 30 -f
# Espera: "Servidor escuchando en el puerto 3001"

Paso 5: Completa el asistente de configuración

Abre en el navegador:

http://<your-clore-server-ip>: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 (multiservicio)

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

Paso 1: Crea el directorio del proyecto

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

Paso 2: Crear docker-compose.yml

cat > docker-compose.yml << 'EOF'
version: '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 (configura uno)
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # Embedding
      EMBEDDING_ENGINE: native
      # BD vectorial
      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"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  anythingllm_storage:
EOF

Paso 3: Crear .env archivo

cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=your-random-64-char-secret-here
EOF

Paso 4: Iniciar

docker compose up -d
docker compose logs anythingllm -f

---

Método 3: Con variables de entorno preconfiguradas

Para una implementación automatizada sin el asistente de configuración:

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 de LLM. Configúralo en la interfaz en Configuración → Preferencia de LLM, o mediante variables de entorno:

OpenAI:

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

Anthropic Claude:

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

Google Gemini:

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

Ollama (local):

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

OpenRouter (acceso a más de 100 modelos):

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

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

# 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 una canalización 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 base de datos vectorial

BD	Descripción	Ideal para
lancedb	Integrado, sin configuración	Predeterminado, conjuntos de datos pequeños y medianos
chroma	ChromaDB (externa)	Conjuntos de datos medianos, flexibilidad
pinecone	nube de Pinecone	Grandes conjuntos de datos, producción
weaviate	Weaviate (autohospedado)	Casos de uso avanzados

Configuración del espacio de trabajo

Los espacios de trabajo de AnythingLLM son entornos aislados con sus propios:

• Base de conocimientos documental

• Configuración de LLM (puede anular la global)

• Historial de chat

• Configuraciones de agentes

Crea espacios de trabajo a través de la UI o la API:

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

Ingesta de documentos

Sube documentos vía UI o API:

# Subir un documento vía API
curl -X POST http://localhost:3001/api/v1/document/upload \
  -H "Authorization: Bearer your-api-key" \
  -F "file=@/path/to/document.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 GPU

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

Ejecutar Ollama en el mismo servidor de Clore.ai

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

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

# Reinicia 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 embedding	Velocidad de inferencia	Coste/hora
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 la ingesta de documentos

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

# Configuración de fragmentación recomendada para distintos tipos de documentos
# Documentos técnicos: tamaño de fragmento 1000, solapamiento 200
# Legales/contratos: tamaño de fragmento 500, solapamiento 100
# Libros/artículos: tamaño de fragmento 1500, solapamiento 300

• Preprocesa PDF grandes — Los escaneos con mucho OCR ralentizan la ingesta. Usa pdftotext o Adobe OCR antes.

• Organiza por espacio de trabajo — Crea espacios de trabajo separados por proyecto/dominio para una mejor precisión de recuperación.

• Usa consultas específicas — RAG funciona mejor con preguntas específicas, no con solicitudes amplias.

Gestión de costes en Clore.ai

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

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

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

• Incrustaciones vectoriales (LanceDB)

• Documentos subidos

• Historial de chat

• Configuraciones de agentes

Configuración multiusuario

# Activa el modo multiusuario en la interfaz:
# Configuración → Seguridad → Activar modo multiusuario

# O mediante variables de entorno:
-e MULTI_USER_MODE=true

# Crear usuario vía API después de activar el modo 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 del agente de IA

Los agentes de AnythingLLM pueden realizar tareas del mundo real. Activa las herramientas en Configuración → Agentes:

• Navegación web — Obtiene y lee páginas web

• Búsqueda de Google — Busca en Google (requiere clave de API)

• Intérprete de código — Ejecuta Python en un entorno aislado

• GitHub — Lee repositorios

• Conector SQL — Consulta bases de datos

# Activa las capacidades del agente mediante variables de 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 del rendimiento

# Para cargas de trabajo intensivas de procesamiento de documentos
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

Actualizando AnythingLLM

# Descarga la imagen más reciente
docker pull mintplexlabs/anythingllm:latest

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

# Detén y elimina el contenedor antiguo (los datos están en el volumen, es seguro)
docker stop anythingllm && docker rm anythingllm

# Reinicia 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 se inicia pero la UI no es accesible

# Comprobar que el contenedor esté en ejecución
docker ps | grep anythingllm

# Comprueba los registros en busca de errores de inicio
docker logs anythingllm --tail 50

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

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

La carga de documentos falla

# Comprueba el espacio libre disponible en disco
df -h

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

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

Las respuestas RAG son de mala calidad / alucinatorias

Causas comunes y soluciones:

# 1. Ajusta el umbral de similitud (más bajo = se recuperan más documentos)
# Configuración → Espacio de trabajo → Base de datos vectorial → Umbral de similitud: 0.5

# 2. Aumenta los resultados top-K
# Configuración → Espacio de trabajo → Base de datos vectorial → Máximo de fragmentos de contexto: 10

# 3. Mejora el tamaño de fragmento (vuelve a ingerir los documentos después de cambiarlo)
# Configuración → Espacio de trabajo → Divisor de texto → Tamaño de fragmento: 1000, Solapamiento: 200

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

La conexión a Ollama falla desde AnythingLLM

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

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

# Alternativa: usa la red del 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

Sin memoria / fallo del contenedor

# Comprueba el uso de memoria
docker stats anythingllm

# Libera memoria reduciendo la caché de LanceDB
# O cambia a una instancia de 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 — configuración completa y referencia de API

• AnythingLLM GitHub — código fuente, incidencias, hoja de ruta

• AnythingLLM Docker Hub — etiquetas de imagen

• Ejecutar Ollama en Clore.ai — backend local de LLM para AnythingLLM

• Ejecutar vLLM en Clore.ai — inferencia de alto rendimiento

• Guía de comparación de GPU — seleccionar el plan adecuado de Clore.ai

• Documentación de MCP — Protocolo de contexto de modelo para ampliar agentes

• Referencia de la API de AnythingLLM — API REST para automatización