AnythingLLM + Ollama: RAG Local Sin Código en tu Homelab (Guía Completa 2025)

¿Quieres que tus LLMs locales con Ollama puedan responder preguntas sobre TUS documentos privados? AnythingLLM es la solución: una plataforma open-source con 50,800 estrellas en GitHub que implementa RAG (Retrieval-Augmented Generation) sin escribir una línea de código.

En esta guía completa aprenderás a instalar AnythingLLM con Docker, conectarlo a Ollama, subir documentos, y crear un chatbot inteligente que cite fuentes exactas de tus PDFs, manuales técnicos, o wikis internas. Todo ejecutándose 100% local en tu homelab.

¿Qué es RAG y Por Qué Revoluciona los LLMs Locales?

El Problema con LLMs Estándar

Los modelos de lenguaje grandes (LLMs) como Llama 3.1 o Mistral tienen un problema fundamental: solo conocen lo que vieron durante su entrenamiento. Si preguntas sobre:

• Tu manual de empleado actualizado en 2025
• Documentación interna de tu empresa
• PDFs técnicos específicos de tu industria
• Procedimientos operativos propios

El LLM responderá: «No tengo acceso a documentos internos…» o peor aún, alucinará una respuesta incorrecta.

La Solución: RAG (Retrieval-Augmented Generation)

RAG añade memoria externa al LLM siguiendo este flujo:

┌──────────────┐
│   Usuario    │
│  "¿Cuántos   │
│  días de     │
│  vacaciones  │
│  tengo?"     │
└──────┬───────┘
       │
       ▼
┌──────────────────────────────┐
│  Sistema RAG                  │
│  1. Busca en documentos      │
│  2. Encuentra: manual_rrhh   │
│     página 15                │
│  3. Extrae contexto relevante│
└──────┬───────────────────────┘
       │
       ▼
┌──────────────────────────────┐
│  LLM (Ollama)                │
│  Recibe:                     │
│  - Pregunta original         │
│  - Contexto: "Empleados      │
│    tienen 22 días..."        │
│  Genera respuesta con cita   │
└──────┬───────────────────────┘
       │
       ▼
┌──────────────────────────────┐
│  "Según manual RRHH (p.15):  │
│  Tienes 22 días laborables   │
│  de vacaciones anuales."     │
│                              │
│  [Fuente: manual_rrhh.pdf]   │
└──────────────────────────────┘

Resultado: El LLM responde con información precisa y cita la fuente exacta.

Los 6 Componentes de RAG

Un sistema RAG completo involucra:

1. Ingestion (Ingestión)

• Cargar documentos (PDF, DOCX, TXT, MD)
• Dividir en fragmentos manejables (chunks de 512-1024 tokens)

2. Embedding (Vectorización)

• Convertir texto a vectores numéricos
• Cada chunk → array de 768 números (ejemplo: nomic-embed-text)

3. Vector Database

• Almacenar embeddings para búsqueda eficiente
• Permite búsqueda por similitud matemática (coseno)

4. Retrieval (Recuperación)

• Usuario pregunta → Se convierte a embedding
• Busca chunks más similares en BD vectorial
• Devuelve top 3-5 fragmentos relevantes

5. Augmentation (Aumentación)

• Combina pregunta + fragmentos recuperados
• Crea prompt enriquecido para el LLM

6. Generation (Generación)

• LLM lee contexto y genera respuesta
• Incluye citaciones automáticas

¿Por qué es revolucionario? Convierte un LLM genérico en un experto sobre TU contenido específico, sin re-entrenar el modelo.

AnythingLLM: La Plataforma RAG Más Completa para Homelab

Características Principales

AnythingLLM no es solo RAG básico. Es una plataforma completa que incluye:

Core Features:

• RAG sin código: Drag & drop de PDFs, TXT, DOCX
• Multi-usuario: Roles (Admin, Manager, User) con permisos granulares
• Chat embebible: Widget JavaScript para tu sitio web
• AI Agents: Builder no-code con acceso a herramientas (web search, bash, Python)
• MCP-compatible: Model Context Protocol estándar (2025)
• Web scraping: Extrae contenido de URLs con Puppeteer integrado

Integraciones LLM (Local):

✅ Ollama (recomendado)
✅ LM Studio
✅ LocalAI
✅ KoboldCPP
✅ Text Generation WebUI

Integraciones LLM (Cloud):

• OpenAI, Anthropic Claude, Google Gemini
• AWS Bedrock, Azure OpenAI
• Groq, Together AI, Mistral, DeepSeek

Modelos de Embedding Soportados:

# Local (self-hosted)
- AnythingLLM Native Embedder (built-in, default)
- Ollama (nomic-embed-text, mxbai-embed-large)
- LM Studio
- LocalAI

# Cloud
- OpenAI (text-embedding-3-small/large)
- Azure OpenAI, Cohere

Vector Databases:

• LanceDB (default, serverless, incluido)
• Chroma, Weaviate, Qdrant, Milvus
• Pinecone (cloud), PGVector (PostgreSQL)

GitHub Stats (Noviembre 2025)

• 50,800 estrellas
• 5,400 forks
• 1,599 commits en master
• 286 issues abiertos (comunidad activa)

Por Qué AnythingLLM vs Alternativas

Conclusión: AnythingLLM gana para usuarios homelab y pequeñas empresas que quieren RAG funcional en minutos. LangChain/LlamaIndex son para developers que necesitan customización extrema.

Requisitos de Sistema y Hardware

Hardware Mínimo (Modelo 7B como Llama 3.1 8B)

CPU:     4 cores (Intel i5-10400, AMD Ryzen 5 3600)
RAM:     8 GB total
         ├─ 4 GB → Ollama + modelo 7B
         ├─ 2 GB → AnythingLLM
         └─ 2 GB → Sistema operativo

Storage: 20 GB
         ├─ 10 GB → Modelo LLM + embeddings
         ├─ 5 GB  → Documentos y vector DB
         └─ 5 GB  → Docker images

GPU:     Opcional (CPU inference funciona)

Performance esperado:

• Generación: ~10-15 tokens/segundo (CPU)
• Embedding de 100 páginas PDF: ~5-10 minutos

Hardware Recomendado (Modelos 13B-34B)

CPU:     6-8 cores (Intel i7/i9, AMD Ryzen 7/9)
RAM:     16-32 GB
GPU:     NVIDIA RTX 3060 (12GB VRAM) o superior
         └─ Acelera inferencia 5-10x vs CPU

Storage: 50-100 GB SSD NVMe
         └─ Vector DB se beneficia de IOPS altos

Performance esperado con GPU:

• Generación: ~50-80 tokens/segundo
• Embedding de 100 páginas: ~30-60 segundos

Software Necesario

# Verificar versiones
docker --version          # Mínimo: 20.10, Recomendado: 25+
docker compose version    # Mínimo: v2.0

# Verificar Ollama está corriendo
curl http://localhost:11434/api/tags

Si no tienes Ollama instalado, revisa nuestra guía completa de Ollama.

Instalación Paso a Paso con Docker

Método 1: Docker Run (Rápido para Pruebas)

# Definir ubicación de almacenamiento
export STORAGE_LOCATION="/var/lib/anythingllm"

# Crear directorios
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"

# Ejecutar AnythingLLM
docker run -d \
  --name anythingllm \
  -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 UID=1000 \
  -e GID=1000 \
  mintplexlabs/anythingllm:master

# Acceder a: http://localhost:3001

⚠️ Nota sobre --cap-add SYS_ADMIN:
Requerido para habilitar web scraping con Puppeteer. Sin esta capability, no podrás extraer contenido de URLs.

Método 2: Docker Compose (Recomendado para Producción)

Crea docker-compose.yml:

version: "3.8"

services:
  # AnythingLLM con configuración completa
  anythingllm:
    image: mintplexlabs/anythingllm:master
    container_name: anythingllm
    hostname: anythingllm
    ports:
      - "3001:3001"
    cap_add:
      - SYS_ADMIN  # Web scraping con Puppeteer
    volumes:
      # Persistencia de datos (documentos, embeddings, config)
      - ./anythingllm/storage:/app/server/storage
      # Variables de entorno
      - ./anythingllm/.env:/app/server/.env
    environment:
      # Storage directory (debe coincidir con volume mount)
      - STORAGE_DIR=/app/server/storage

      # User/Group IDs (verificar con: id -u && id -g)
      - UID=1000
      - GID=1000

      # Opcional: Configurar LLM por defecto via env vars
      # - LLM_PROVIDER=ollama
      # - OLLAMA_BASE_URL=http://host.docker.internal:11434
    restart: unless-stopped
    networks:
      - llm_network

  # Opcional: Ollama en el mismo stack
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    hostname: ollama
    ports:
      - "11434:11434"
    volumes:
      # Persistir modelos descargados
      - ./ollama/models:/root/.ollama
    restart: unless-stopped
    networks:
      - llm_network
    # Descomentar si tienes GPU NVIDIA
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]

networks:
  llm_network:
    driver: bridge

Iniciar el stack:

# Crear directorios
mkdir -p anythingllm/storage ollama/models
touch anythingllm/.env

# Verificar tu UID/GID
id -u  # Output: 1000 (o tu ID real)
id -g  # Output: 1000

# Editar docker-compose.yml si tu UID != 1000

# Iniciar servicios
docker compose up -d

# Ver logs
docker compose logs -f anythingllm

# Esperar mensaje: "Server listening on port 3001"

Acceder a la aplicación:

• URL: http://localhost:3001
• Registro del primer usuario (será admin automáticamente)

Troubleshooting: Problemas de Permisos

Si ves errores como EACCES: permission denied:

# Verificar UID/GID actual
echo "UID: $(id -u), GID: $(id -g)"

# Editar docker-compose.yml
environment:
  - UID=TU_UID_AQUI  # ← Reemplazar
  - GID=TU_GID_AQUI  # ← Reemplazar

# Reiniciar
docker compose down
docker compose up -d

Configurar Ollama como Proveedor LLM

Paso 1: Preparar Ollama

# Verificar Ollama está accesible
curl http://localhost:11434/api/tags

# Descargar modelo LLM (elige uno según tu RAM)
# Opción 1: Llama 3.1 8B (Recomendado para 8-16GB RAM)
ollama pull llama3.1:8b

# Opción 2: Mistral 7B (Muy rápido, bueno para RAG)
ollama pull mistral:7b-instruct

# Opción 3: Gemma 2 9B (Mejor para español)
ollama pull gemma2:9b

# Descargar modelo de embedding (CRÍTICO para RAG)
ollama pull nomic-embed-text

Modelos de embedding explicados:

Recomendación: nomic-embed-text tiene el mejor balance precisión/recursos.

Paso 2: Conectar Ollama en AnythingLLM

A) Si Ollama corre en el HOST y AnythingLLM en Docker:

1. Accede a: http://localhost:3001
2. Settings (⚙️) → LLM Preference
3. LLM Provider: Selecciona "Ollama"
4. Ollama Base URL: http://host.docker.internal:11434
5. Token Context Window: 8192 (para Llama 3.1 8B)
6. Model: Selecciona "llama3.1:8b" del dropdown
7. Save

B) Si ambos están en el mismo Docker Compose:

Ollama Base URL: http://ollama:11434
(Usa el nombre del servicio como hostname)

Paso 3: Configurar Embedder

1. Settings → Embedding Preference
2. Embedding Provider: Selecciona "Ollama"
3. Ollama Base URL: (igual que LLM)
4. Embedding Model: nomic-embed-text
5. Max embedding chunk length: 8192 (default OK)
6. Save

Verificar Configuración

1. Ve a cualquier workspace
2. Escribe mensaje de prueba: "¿Qué modelos tienes disponibles?"
3. Si funciona → Configuración correcta ✅
4. Si error "Cannot connect to Ollama" → Ver troubleshooting abajo

Crear tu Primer Sistema RAG: Caso Práctico

Vamos a crear un chatbot que responda preguntas sobre un manual técnico de 100 páginas.

Paso 1: Crear Workspace

1. Sidebar izquierdo → Click "+" (New Workspace)
2. Nombre: "Manual Técnico Producto XYZ"
3. Icono: Elige uno (ej: 📚)
4. Click "Create Workspace"

Concepto de Workspace:
Cada workspace es un chatbot independiente con su propia base de conocimiento (documentos). Puedes tener:

• Workspace “RRHH” con manuales de empleados
• Workspace “Ingeniería” con docs técnicas
• Workspace “Ventas” con catálogos de productos

Paso 2: Subir Documentos

1. Dentro del workspace → Click "Upload Document"
2. Drag & drop: manual_tecnico.pdf (o múltiples archivos)
3. AnythingLLM procesa automáticamente:
   ┌─────────────────────────────────┐
   │ Procesando...                   │
   │ ▸ Extrayendo texto del PDF      │
   │ ▸ Dividiendo en chunks (512t)   │
   │ ▸ Generando embeddings          │
   │   (nomic-embed-text via Ollama) │
   │ ▸ Almacenando en LanceDB        │
   │ Progress: ████████░░ 80%         │
   └─────────────────────────────────┘
4. Tiempo típico: ~5 min para PDF de 100 páginas (CPU)

Tipos de archivos soportados:

• Documentos: PDF, DOCX, PPTX, TXT, MD, CSV
• Código: .py, .js, .java, .cpp (preserva syntax highlighting)
• Web: URL directa (se hace scraping automático)
• Media: Audio MP3/WAV (transcripción con Whisper), Video (subtítulos)

Paso 3: Mover Documentos al Workspace

1. Una vez procesados, documentos aparecen en "Document Library"
2. Select checkbox de "manual_tecnico.pdf"
3. Click "Move to Workspace"
4. Dropdown: Selecciona "Manual Técnico Producto XYZ"
5. Confirm

Ahora el chatbot tiene acceso a este documento.

Paso 4: Chatear con RAG Activo

Ejemplo de conversación:

Usuario: ¿Cómo instalar el firmware v2.5?

AnythingLLM (internamente):
1. Convierte pregunta a embedding [0.234, -0.567, 0.891, ...]
2. Busca en vector DB chunks similares
3. Encuentra (similitud >0.7):
   - Chunk #47: "Instalación firmware... paso 1: conectar USB..."
   - Chunk #48: "...firmware v2.5 requiere bootloader v1.2..."
   - Chunk #49: "...utilizar FirmwareFlasher.exe con flag -f..."
4. Envía a Ollama:
   Pregunta: "¿Cómo instalar firmware v2.5?"
   Contexto: [Chunks 47, 48, 49]
5. Ollama genera respuesta citando fuente

Respuesta visible:
---
Para instalar firmware v2.5 (según Manual Técnico p.23-24):

**Requisitos previos:**
- Bootloader v1.2 o superior
- Cable USB-C original
- Software FirmwareFlasher.exe

**Pasos:**
1. Conecta dispositivo via USB-C
2. Abre FirmwareFlasher.exe
3. Ejecuta: `FirmwareFlasher.exe -f firmware_v2.5.bin -verify`
4. Espera mensaje "Flash completed successfully"
5. Reinicia dispositivo

⚠️ NO desconectes durante proceso (puede brickear dispositivo)

📄 **Fuentes citadas:**
- manual_tecnico.pdf - Página 23
- manual_tecnico.pdf - Página 24
---

Ventajas vs LLM sin RAG:

• ✅ Información precisa extraída de TU manual
• ✅ Citas exactas con número de página
• ✅ No alucina pasos inventados
• ✅ Actualizable (sube nuevo manual → conocimiento actualizado)

Paso 5: Refinar con Configuración Avanzada

Settings del Workspace → RAG Settings:

Top K Context:
  Valor: 3-5
  Qué hace: Número de chunks a recuperar
  Recomendación:
    - 3 → Respuestas concisas, documentos técnicos
    - 5 → Respuestas completas, FAQs extensas

Similarity Threshold:
  Valor: 0.5-0.8
  Qué hace: Mínimo de similitud para incluir chunk
  Recomendación:
    - 0.7 → Estricto (solo muy relevante)
    - 0.5 → Permisivo (incluye contexto amplio)

Max Token Window:
  Valor: 8192 (Llama 3.1 8B)
  Qué hace: Cuánto contexto cabe en el prompt
  Nota: No cambiar salvo que uses modelo diferente

Funcionalidades Avanzadas

Multi-Usuario con Permisos

AnythingLLM en Docker soporta múltiples usuarios con roles:

Crear usuarios:

1. Settings → Users
2. Click "Add User"
3. Email: usuario@empresa.com
4. Password: (genera segura)
5. Role:
   - Admin: Acceso total, gestión usuarios
   - Manager: Crea workspaces, sube docs
   - Default: Solo chatea en workspaces asignados
6. Assign Workspaces: Selecciona a cuáles tiene acceso
7. Create

Caso de uso:

Empresa con 3 departamentos:
- Workspace "RRHH" → Solo acceso: equipo RRHH + CEO
- Workspace "Ventas" → Acceso: equipo ventas
- Workspace "General" → Acceso: todos

Ingeniero de ventas NO puede ver docs de RRHH (privacidad)

Chat Widget Embebible en tu Web

Convierte tu RAG en chatbot público para tu sitio:

1. Settings → Embed Chats
2. Click "Create new embed"
3. Select Workspace: (ej: "Soporte Producto")
4. Customize:
   - Chat bubble color
   - Welcome message
   - Logo de empresa
5. Copy JavaScript snippet:

<script
  src="http://localhost:3001/embed/ABC123.js"
  data-embed-id="ABC123">
</script>

6. Pega en tu HTML → Widget aparece esquina inferior derecha

Nota: Requiere reverse proxy con HTTPS para producción (Nginx, Traefik).

AI Agents con Herramientas

Crea agentes que ejecutan acciones (experimental):

1. Workspace → Agent Configuration
2. Enable Agent Mode: ON
3. Available Tools:
   ✅ Web Search (busca en internet para actualizar respuestas)
   ✅ Web Scraping (extrae contenido de URLs on-demand)
   ✅ Chart Generation (genera gráficos con datos)
   ⚠️ Code Execution (Python/JS sandbox - CUIDADO)
4. Agent Skill: Selecciona level
   - Passive: Solo responde
   - Active: Usa herramientas cuando detecta necesidad
5. Save

Ejemplo de uso:
Usuario: "¿Cuál es el precio actual de Bitcoin?"
Agente:
  1. Detecta necesidad de dato actualizado
  2. Ejecuta web_search("bitcoin price")
  3. Combina resultado con conocimiento base
  4. Responde: "Según CoinGecko, BTC está en $67,234 (actualizado hace 5 min)"

Optimización de Performance

Chunking Strategy Óptima

El tamaño de chunks afecta directamente la calidad de las respuestas:

# Configuración por tipo de documento

Documentos técnicos (manuales, specs):
  Chunk size: 512 tokens
  Overlap: 50 tokens
  Razón: Procedimientos completos caben en 1-2 chunks

Libros / narrativa:
  Chunk size: 1024 tokens
  Overlap: 100 tokens
  Razón: Contexto narrativo más amplio

FAQs / Q&A:
  Chunk size: 256 tokens
  Overlap: 25 tokens
  Razón: Cada pregunta-respuesta es un chunk independiente

Código fuente:
  Chunk size: 1024 tokens
  Overlap: 200 tokens (2 funciones)
  Razón: Funciones completas con imports

Configurar en AnythingLLM:

Settings → Document Processor → Text Splitter
- Max chunk size: 512 (ajustar según tipo)
- Overlap: 50

Acelerar Embeddings con GPU

Si tienes GPU NVIDIA, embeddings van 10x más rápido:

# docker-compose.yml
ollama:
  # ... configuración existente ...
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            count: 1
            capabilities: [gpu]

Benchmark (1000 páginas PDF):

• CPU Intel i5-10400: ~30 minutos
• GPU RTX 3060: ~3 minutos (10x faster)

Selección de Vector Database

Recomendación: LanceDB (default) es perfecto para 99% de homelab use cases.

Cambiar Vector DB:

Settings → Vector Database
- Provider: Chroma
- Host: http://chroma:8000
- Collection: my_docs

Comparativa: AnythingLLM vs Alternativas Open-Source

OpenWebUI

Similitudes:

• UI web moderna
• Soporte Ollama
• Docker single-container
• Comunidad activa

Diferencias clave:

Cuándo usar OpenWebUI: Si solo quieres chatear con modelos locales sin RAG complejo.

Cuándo usar AnythingLLM: Si necesitas RAG robusto con documentos de empresa.

LangChain + Streamlit

Similitudes:

• RAG completo
• Customizable
• Open-source

Diferencias:

Cuándo usar LangChain: Eres developer y necesitas workflows RAG altamente específicos.

Cuándo usar AnythingLLM: Quieres RAG funcional HOY sin escribir código.

Troubleshooting de Problemas Comunes

“Cannot connect to Ollama”

Síntoma: Error en LLM Settings al guardar configuración Ollama.

Diagnóstico:

# 1. Verificar Ollama está corriendo
curl http://localhost:11434/api/tags
# Debe devolver JSON con lista de modelos

# 2. Si error "Connection refused":
systemctl status ollama  # Linux
# o
ps aux | grep ollama  # Verificar proceso corriendo

Solución según escenario:

A) Ollama en HOST, AnythingLLM en Docker:

Ollama Base URL: http://host.docker.internal:11434

Razón: Docker container no puede acceder a localhost del host
Solución especial: host.docker.internal → IP del host

B) Ambos en Docker Compose:

Ollama Base URL: http://ollama:11434

Razón: Usar nombre del servicio como hostname

C) Ollama en servidor remoto:

Ollama Base URL: http://192.168.1.100:11434

Nota: Asegurar firewall permite puerto 11434

Embeddings Muy Lentos (>10 min para 50 páginas)

Causas posibles:

• Usando CPU sin AVX2:

# Verificar soporte AVX2
lscpu | grep avx2

# Si NO aparece → CPU viejo sin aceleración vectorial
# Solución: Considerar upgrade CPU o usar GPU

• Modelo embedding muy grande:

# Si usas mxbai-embed-large (669 MB):
ollama pull nomic-embed-text  # Cambiar a más ligero (274 MB)

# Configurar en AnythingLLM:
Settings → Embedding → nomic-embed-text

• Falta de GPU para Ollama:

# Habilitar GPU en docker-compose.yml
ollama:
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            count: all
            capabilities: [gpu]

“Permission denied” al Iniciar Container

Síntoma:

Error: EACCES: permission denied, mkdir '/app/server/storage/documents'

Causa: UID/GID mismatch entre host y container.

Solución:

# 1. Verificar tu UID y GID
id
# Output: uid=1001(tu_usuario) gid=1001(tu_grupo)

# 2. Editar docker-compose.yml
environment:
  - UID=1001  # ← Cambiar al UID real
  - GID=1001  # ← Cambiar al GID real

# 3. Cambiar ownership de directorios existentes
sudo chown -R 1001:1001 ./anythingllm/storage

# 4. Reiniciar
docker compose restart anythingllm

Documentos Subidos No Aparecen en Chat

Síntoma: Subes PDF pero el chatbot dice “No tengo información sobre eso”.

Diagnóstico:

1. Ve a Document Library
2. Verifica documento está "Embedded" (no "Processing...")
3. Si sigue en "Processing" por >15 min → Error embedding

Revisar logs:
docker compose logs anythingllm | grep -i error

Causas comunes:

A) Documento no movido a Workspace:

Solución:
Document Library → Select documento → Move to Workspace → Select workspace

B) Embedding model no configurado:

Síntoma en logs: "No embedding provider configured"

Solución:
Settings → Embedding Preference → Selecciona "Ollama" → Save

C) Documento corrompido:

Síntoma: PDF no se procesa nunca

Solución:
- Abrir PDF en visor externo (verificar no corrupto)
- Exportar a PDF nuevo desde LibreOffice/Adobe
- Intentar subir de nuevo

Integración con n8n: Automatiza tu RAG

Una de las integraciones más poderosas es combinar AnythingLLM con n8n para automatización. Esto permite crear workflows que procesan documentos automáticamente.

Workflow: Auto-Procesamiento de Emails con RAG

Caso de uso: Analizar emails de clientes y responder con info de tu base de conocimiento.

Configuración n8n:

{
  "nodes": [
    {
      "name": "Email Trigger",
      "type": "n8n-nodes-base.emailReadImap",
      "parameters": {
        "mailbox": "INBOX",
        "markAsRead": true
      }
    },
    {
      "name": "Extract Attachment",
      "type": "n8n-nodes-base.extractFromFile",
      "parameters": {
        "binaryPropertyName": "attachment0"
      }
    },
    {
      "name": "Query AnythingLLM",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "http://anythingllm:3001/api/v1/workspace/chat",
        "method": "POST",
        "authentication": "headerAuth",
        "headerAuth": {
          "name": "Authorization",
          "value": "Bearer YOUR_API_KEY"
        },
        "body": {
          "message": "{{ $json.emailBody }}",
          "mode": "query"
        }
      }
    },
    {
      "name": "Send Response",
      "type": "n8n-nodes-base.emailSend",
      "parameters": {
        "toEmail": "{{ $json.fromEmail }}",
        "subject": "Re: {{ $json.subject }}",
        "text": "{{ $json.response }}"
      }
    }
  ]
}

Flujo:

• Email llega → n8n detecta
• Extrae pregunta del cliente
• Consulta AnythingLLM RAG con base de conocimiento
• Genera respuesta con citaciones
• Envía email automático con respuesta

Tiempo de respuesta: <30 segundos vs horas con humano.

API de AnythingLLM para Integraciones Custom

AnythingLLM expone API REST completa:

# Autenticación: Obtener API Key
# Settings → API Keys → Generate New Key

# Ejemplo: Query a workspace
curl -X POST http://localhost:3001/api/v1/workspace/my-docs/chat \
  -H "Authorization: Bearer sk-anythingllm-..." \
  -H "Content-Type: application/json" \
  -d '{
    "message": "¿Cómo resetear dispositivo?",
    "mode": "query"
  }'

# Response:
{
  "id": "msg-123",
  "response": "Para resetear (según manual p.47): ...",
  "sources": [
    {
      "title": "manual_tecnico.pdf",
      "chunk": "Resetear dispositivo...",
      "score": 0.89
    }
  ],
  "type": "textResponse"
}

Endpoints útiles:

• /api/v1/workspace/:slug/chat – Enviar mensaje
• /api/v1/document/upload – Subir documento programáticamente
• /api/v1/workspace/:slug/update-embeddings – Re-embedear docs
• /api/v1/system/stats – Estadísticas de uso

Esto permite integrar RAG con cualquier sistema existente: CRM, helpdesk, apps custom.

Casos de Uso Reales en Producción

1. Soporte Técnico Automatizado

Setup:

Workspace: "Base Conocimiento Soporte"
Documentos:
  - Manual de usuario (PDF 200 páginas)
  - FAQs compiladas (DOCX)
  - Base de datos de errores comunes (CSV)
  - Changelog de últimos 12 meses (MD)

LLM: Mistral 7B Instruct (rápido, preciso)
Embedder: nomic-embed-text

Widget embebido en:
  - Sitio web de soporte
  - Portal de clientes
  - App móvil (iframe)

Resultado:
  - 60% de tickets resueltos sin humano
  - Tiempo respuesta: <10 segundos
  - Satisfacción usuarios: 4.2/5

2. Onboarding de Empleados

Setup:

Workspaces múltiples:
  - "RRHH General" → Políticas, beneficios, calendario
  - "IT Onboarding" → Setup laptop, accesos, herramientas
  - "Código de Conducta" → Normas internas, compliance

Multi-usuario:
  - Nuevos empleados → Acceso a los 3 workspaces (read-only)
  - RRHH → Admin (puede actualizar docs)

Documentos auto-actualizados:
  - Script cron sube nueva versión de manual_empleado.pdf diario
  - Webhook n8n detecta cambio → Re-embedding automático

3. Análisis de Contratos Legales

Setup:

Workspace: "Revisión Contratos"
Documentos:
  - Plantillas de contratos estándar
  - Cláusulas pre-aprobadas por legal
  - Casos de conflictos anteriores

LLM: Llama 3.1 70B (máxima precisión)
Hardware: GPU A100 40GB

Workflow:
  1. Usuario sube contrato nuevo (PDF)
  2. Pregunta: "¿Hay cláusulas que difieren de nuestro estándar?"
  3. LLM compara con plantillas en RAG
  4. Lista diferencias con citaciones exactas
  5. Abogado revisa solo secciones flagged (90% tiempo ahorrado)

Preguntas Frecuentes (FAQ)

¿Puedo usar modelos comerciales (OpenAI) en lugar de Ollama?

Sí, AnythingLLM soporta:

Settings → LLM Provider → OpenAI
API Key: sk-...
Model: gpt-4o

Ventaja: Mejor razonamiento complejo
Desventaja: Costo por token, datos salen de tu servidor

Recomendación: Ollama para datos sensibles, OpenAI para casos no-críticos.

¿Cuántos documentos puedo subir?

Límites prácticos:

Nota: No es límite hard, depende de tamaño chunks y modelo embedding.

Cómo escalar más allá:

Si necesitas >200k páginas, considera:

• Múltiples workspaces especializados (divide por tema)
• Vector DB externa (Qdrant en servidor dedicado con 64GB RAM)
• Clustering de embeddings (reduce dimensionalidad de 768 → 384)
• Archivo de docs antiguos (keep solo últimos 2 años activos)

Empresas grandes (>1M páginas) típicamente usan Weaviate o Pinecone cloud tier enterprise.

¿RAG funciona con código fuente?

Sí, muy bien:

Soportado:
  .py, .js, .ts, .java, .cpp, .go, .rs, .php, .rb, .sh

Uso típico:
  - Sube repo completo (export GitHub como ZIP)
  - Pregunta: "¿Cómo funciona el sistema de autenticación?"
  - RAG encuentra archivos auth.py, middleware.js
  - LLM explica flujo citando líneas específicas

¿Puedo combinar múltiples modelos (ej: Mistral para chat, Llama para código)?

No directamente en un workspace, pero workaround:

Workspace "General" → LLM: Mistral 7B
Workspace "Code Review" → LLM: DeepSeek Coder 33B

Usuario cambia de workspace según necesidad

¿AnythingLLM almacena datos en la nube?

NO, con configuración local (Ollama + LanceDB):

Datos que NO salen de tu servidor:
  ✅ Documentos subidos
  ✅ Embeddings generados
  ✅ Historial de chat
  ✅ Inferencia del LLM

Datos que SÍ salen (solo si habilitas):
  ⚠️ Telemetría anónima (opt-out en Settings)
  ⚠️ Updates check (puede deshabilitarse)

Para paranoia máxima:

# docker-compose.yml
environment:
  - DISABLE_TELEMETRY=true
  - OFFLINE_MODE=true  # No check de updates

¿Cómo actualizo AnythingLLM sin perder datos?

# 1. Backup de datos (crítico)
cp -r ./anythingllm/storage ./anythingllm/storage.backup

# 2. Pull nueva imagen
docker compose pull anythingllm

# 3. Reiniciar con nueva versión
docker compose up -d

# 4. Verificar logs sin errores
docker compose logs -f anythingllm

# Si algo falla: restore backup
rm -rf ./anythingllm/storage
mv ./anythingllm/storage.backup ./anythingllm/storage
docker compose restart

¿Puedo exponer AnythingLLM a internet de forma segura?

Sí, con reverse proxy HTTPS:

# /etc/nginx/sites-enabled/anythingllm.conf
server {
    listen 443 ssl http2;
    server_name rag.midominio.com;

    ssl_certificate /etc/letsencrypt/live/rag.midominio.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/rag.midominio.com/privkey.pem;

    location / {
        proxy_pass http://localhost:3001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Seguridad adicional:

• Habilita autenticación (multi-usuario AnythingLLM)
• Rate limiting en Nginx
• Firewall (solo puerto 443 expuesto)
• Fail2ban contra brute force

¿Cuánto cuesta ejecutar AnythingLLM vs soluciones cloud?

AnythingLLM + Ollama (homelab):

Hardware one-time:
  Mini-PC (i5, 16GB, 512GB): €400
  GPU opcional (RTX 3060): €300
  Total: €700

Electricidad mensual:
  Sin GPU: ~20W × 730h × €0.15/kWh = €2.19/mes
  Con GPU: ~80W × 730h × €0.15/kWh = €8.76/mes

Costo 3 años: €700 + (€8.76 × 36) = €1,015

OpenAI Assistants API (cloud):

Embedding: $0.02/1k tokens
Query: $0.03/1k tokens

Ejemplo: 10,000 docs (5M tokens embedding):
  Initial embedding: $100
  100k queries/mes (5M tokens): $150/mes

Costo 3 años: $100 + ($150 × 36) = $5,500

ROI: AnythingLLM se paga en ~7 meses para uso moderado-alto.

¿AnythingLLM soporta multilenguaje (español)?

Sí, depende del modelo LLM:

Mejor soporte español:

1. Gemma 2 9B (Google) → Excelente español
2. Llama 3.1 8B (Meta) → Muy bueno
3. Mistral 7B → Bueno

Embeddings:
  - nomic-embed-text → Multilingual (incluye español)

Nota: RAG en español funciona mejor con docs en español (obvio). Mix español-inglés funciona OK.

Benchmark propio (100 preguntas en español):

Todos funcionan bien, pero Gemma 2 destaca en contexto latinoamericano vs España (vocabulario regionalizado).

Conclusión: ¿Vale la Pena AnythingLLM en 2025?

AnythingLLM ha alcanzado un nivel de madurez que lo convierte en la solución RAG self-hosted más accesible del mercado open-source.

Cuándo AnythingLLM es la Mejor Elección

✅ Privacidad crítica: Documentos médicos, legales, RRHH, IP propietaria.

✅ Volumen alto de documentos: >100 PDFs que necesitas consultar frecuentemente.

✅ Equipo no-técnico: RRHH, ventas, soporte que necesitan RAG sin aprender Python.

✅ ROI rápido: Uso intensivo justifica inversión hardware en <1 año vs APIs cloud.

✅ Homelab existente: Ya tienes servidor con Ollama, añades AnythingLLM en 10 minutos.

Cuándo Considerar Alternativas

❌ Solo necesitas chatear: OpenWebUI es más simple si no requieres RAG complejo.

❌ Workflows RAG muy custom: LangChain/LlamaIndex si necesitas lógica específica.

❌ Zero mantenimiento: Soluciones cloud (OpenAI Assistants, Anthropic Claude Projects) si prefieres pagar vs gestionar.

❌ Hardware limitado: <8GB RAM → Mejor APIs cloud con tier gratuito.

Próximos Pasos Recomendados

Si decides implementar AnythingLLM:

Semana 1: Setup básico

• Instalar stack Docker (AnythingLLM + Ollama)
• Descargar modelo LLM (Llama 3.1 8B) y embedding (nomic-embed-text)
• Crear workspace de prueba con 10-20 PDFs
• Testear calidad de respuestas, ajustar chunking si es necesario

Semana 2: Optimización

• Añadir GPU si tienes disponible (10x speedup embeddings)
• Configurar multi-usuario si es para equipo
• Implementar backup automático (cron + rsync)
• Documentar proceso para colegas

Semana 3: Producción

• Migrar documentos reales (cientos de PDFs)
• Crear workspaces especializados por departamento
• Configurar reverse proxy HTTPS si acceso remoto
• Integrar con n8n o API para workflows automatizados

Mes 2: Expansión

• Chat widget embebible en sitio web
• AI Agents con herramientas (web search, code execution)
• Conectar a Slack/Discord para chatbot interno
• Monitoreo con Uptime Kuma o Prometheus

La Apuesta a Futuro

Con 50,800 estrellas en GitHub, actualizaciones continuas, y una comunidad activa, AnythingLLM está bien posicionado para seguir siendo relevante en 2025-2026.

La combinación con Ollama crea un stack 100% local, privado, y sin costes recurrentes que rivaliza con soluciones enterprise de $1000+/mes.

Si estás construyendo tu homelab de IA, AnythingLLM es la pieza que convierte tus LLMs locales en herramientas realmente útiles para casos de uso reales.

¿Listo para empezar? Descarga el docker-compose.yml de esta guía y en 15 minutos tendrás tu propio ChatGPT privado con acceso a tus documentos: https://github.com/Mintplex-Labs/anything-llm