Plataforma RAG AnythingLLM

Despliega AnythingLLM en Clore.ai: aplicación RAG todo-en-uno y plataforma de agentes AI con chat de documentos integrado, constructor de agentes sin código y soporte MCP en servidores cloud GPU rentables.

Resumen

AnythingLLM 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

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

Paso 2: Configurar el directorio de almacenamiento

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

Paso 3: Ejecutar 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 scraping de páginas web y renderizado de PDF, lo que requiere capacidades elevadas en el contenedor.

Paso 4: Verificar el inicio

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:

Crear cuenta de administrador
Elegir proveedor de LLM
Elegir modelo de embedding
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

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

Paso 2: Crear docker-compose.yml

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

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

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:

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:

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

Motor

Backend

Necesita GPU

Calidad

native

CPU (integrado)

Bueno

openai

API de OpenAI

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

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:

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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

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

# 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

# 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

# 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 — instalación completa y referencia de API
AnythingLLM en GitHub — código fuente, issues, hoja de ruta
AnythingLLM en Docker Hub — etiquetas de imagen
Ejecutando Ollama en Clore.ai — backend LLM local para AnythingLLM
Ejecutando vLLM en Clore.ai — inferencia de alto rendimiento
Guía de comparación de GPU — seleccionar el nivel adecuado de Clore.ai
Documentación MCP — Model Context Protocol para extender agentes
Referencia de la API de AnythingLLM — API REST para automatización

AnteriorLibreChat Multi-Proveedor SiguienteAsistente offline Jan.ai

Última actualización hace 17 días

¿Te fue útil?

hashtagResumen

hashtagDescripción general de la arquitectura

hashtagRequisitos

hashtagEspecificaciones del servidor

hashtagReferencia de precios de Clore.ai

hashtagPrerrequisitos

hashtagInicio rápido

hashtagMétodo 1: Contenedor Docker único (Recomendado)

hashtagMétodo 2: Docker Compose (Multi-Servicio)

hashtagMétodo 3: Con variables de entorno preconfiguradas

hashtagConfiguración

hashtagOpciones de proveedor de LLM

hashtagConfiguración de Embeddings

hashtagOpciones de bases de datos vectoriales

hashtagConfiguración del espacio de trabajo

hashtagIngestión de documentos

hashtagAceleración por GPU

hashtagEjecutando Ollama en el mismo servidor Clore.ai

hashtagRendimiento de modelos GPU en Clore.ai

hashtagConsejos y mejores prácticas

hashtagMejores prácticas para ingestión de documentos

hashtagGestión de costos en Clore.ai

hashtagConfiguración multiusuario

hashtagConfiguración de agentes de IA

hashtagAjuste de rendimiento

hashtagActualizar AnythingLLM

hashtagSolución de problemas

hashtagEl contenedor inicia pero la UI no es accesible

hashtagLa subida de documentos falla

hashtagLas respuestas RAG son de mala calidad / con alucinaciones

hashtagLa conexión a Ollama falla desde AnythingLLM

hashtagFalta de memoria / fallo del contenedor

hashtagLecturas adicionales

Resumen

Descripción general de la arquitectura

Requisitos

Especificaciones del servidor

Referencia de precios de Clore.ai

Prerrequisitos

Inicio rápido

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

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

Método 3: Con variables de entorno preconfiguradas

Configuración

Opciones de proveedor de LLM

Configuración de Embeddings

Opciones de bases de datos vectoriales

Configuración del espacio de trabajo

Ingestión de documentos

Aceleración por GPU

Ejecutando Ollama en el mismo servidor Clore.ai

Rendimiento de modelos GPU en Clore.ai

Consejos y mejores prácticas

Mejores prácticas para ingestión de documentos

Gestión de costos en Clore.ai

Configuración multiusuario

Configuración de agentes de IA

Ajuste de rendimiento

Actualizar AnythingLLM

Solución de problemas

El contenedor inicia pero la UI no es accesible

La subida de documentos falla

Las respuestas RAG son de mala calidad / con alucinaciones

La conexión a Ollama falla desde AnythingLLM

Falta de memoria / fallo del contenedor

Lecturas adicionales