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

# 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](https://github.com/Mintplex-Labs/anything-llm) 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](https://clore.ai/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**

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

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

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

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

**Paso 4: Verifica el inicio**

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

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

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

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

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

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

```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 de LLM. Configúralo en la interfaz en **Configuración → Preferencia de LLM**, o mediante 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 más de 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 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        |

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

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

### Ingesta de documentos

Sube documentos vía UI o 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=@/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

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

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

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

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

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

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

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

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

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

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

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

```bash
# 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](https://docs.anythingllm.com) — configuración completa y referencia de API
* [AnythingLLM GitHub](https://github.com/Mintplex-Labs/anything-llm) — código fuente, incidencias, hoja de ruta
* [AnythingLLM Docker Hub](https://hub.docker.com/r/mintplexlabs/anythingllm) — etiquetas de imagen
* [Ejecutar Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — backend local de LLM para AnythingLLM
* [Ejecutar 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 plan adecuado de Clore.ai
* [Documentación de MCP](https://modelcontextprotocol.io) — Protocolo de contexto de modelo para ampliar agentes
* [Referencia de la API de AnythingLLM](https://docs.anythingllm.com/api-reference) — API REST para automatización


---

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