Asistente AI LobeChat

Despliega LobeChat en Clore.ai — una interfaz de chat de IA impresionante y rica en funciones con soporte multi-proveedor, base de conocimientos y plugins ejecutándose en servidores en la nube respaldados por GPU y asequibles.

Resumen

LobeChat es un marco de chat de IA moderno y de código abierto con más de 55K estrellas en GitHub, conocido por su interfaz pulida y su extenso conjunto de funciones. Admite prácticamente todos los principales proveedores de LLM: OpenAI, Anthropic Claude, Google Gemini, Mistral y modelos locales a través de Ollama, todo desde una única interfaz autohospedada.

¿Por qué ejecutar LobeChat en Clore.ai?

• No se requiere GPU — El propio LobeChat es una aplicación web ligera. Las instancias de Clore.ai solo con CPU o con GPU mínima son perfectamente suficientes para la interfaz.

• Emparejar con LLMs locales — Inicia Ollama o vLLM en el mismo servidor Clore.ai y configura LobeChat para usarlo para inferencia totalmente local y privada.

• Alojamiento asequible — Una instancia básica de Clore.ai cuesta una fracción de los proveedores VPS tradicionales, y puedes apagarla cuando no la uses.

• Propiedad total de los datos — El modo Base de datos almacena todas las conversaciones, archivos y embeddings en tu propia instancia de PostgreSQL en el servidor.

LobeChat opera en dos modos distintos:

Modo	Descripción	Mejor para
Independiente	Contenedor Docker único, configuración almacenada en el navegador	Pruebas rápidas, uso personal
Base de datos	Pila completa (PostgreSQL + MinIO + Auth + App)	Equipos, historial persistente, base de conocimientos

---

Requisitos

Especificaciones del servidor

Componente	Mínimo	Recomendado	Notas
GPU	Ninguna requerida	RTX 3090 (si ejecutas LLMs locales)	Solo necesaria para backend Ollama/vLLM
VRAM	—	24 GB (RTX 3090)	Para inferencia de modelos locales
CPU	2 vCPU	4+ vCPU	El propio LobeChat es ligero
RAM	2 GB	8 GB	4+ GB si usas el modo base de datos
Almacenamiento	10 GB	50+ GB	Más si almacenas archivos subidos o modelos

Referencia de precios de Clore.ai

Tipo de servidor	Costo aprox.	Caso de uso
Instancia solo CPU	~$0.05–0.10/h	Solo LobeChat independiente
RTX 3090 (24 GB VRAM)	~$0.20/h	LobeChat + Ollama LLMs locales
RTX 4090 (24 GB VRAM)	~$0.35/h	LobeChat + inferencia local más rápida
A100 80 GB	~$1.10/h	LobeChat + modelos grandes (70B+)

💡 Consejo: Para uso solo vía API (conectándose a OpenAI, Anthropic, etc.), cualquier instancia pequeña funciona. Un servidor con GPU solo tiene sentido si también quieres ejecutar LLMs locales. Ver Guía de comparación de GPU para más detalles.

Prerrequisitos

• Cuenta de Clore.ai con un servidor desplegado

• Acceso SSH a tu servidor

• Docker y Docker Compose (preinstalados en servidores Clore.ai)

• Controladores NVIDIA (preinstalados; solo relevantes si usas el backend LLM local)

• Al menos una clave API (OpenAI, Anthropic, etc.) o una instancia local de Ollama

---

Inicio rápido

Opción A: Modo independiente (recomendado para empezar)

El modo independiente ejecuta LobeChat como un único contenedor. La configuración y el historial de conversaciones se almacenan en el almacenamiento local del navegador: no se requiere base de datos.

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

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

Paso 2: Descargar y ejecutar LobeChat

docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OPENAI_API_KEY=sk-tu-clave-openai-aqui \
  -e OPENAI_PROXY_URL=https://api.openai.com/v1 \
  lobehub/lobe-chat

Paso 3: Verificar que está en ejecución

docker ps
docker logs lobechat --tail 20

Paso 4: Acceder a la interfaz

Abre tu navegador y navega a:

http://<tu-ip-servidor-clore>:3210

⚠️ Nota de seguridad: Los servidores Clore.ai son accesibles públicamente. Considera configurar ACCESS_CODE para proteger con contraseña tu instancia (ver la sección de Configuración más abajo).

---

Opción B: Independiente con múltiples proveedores

Pasa múltiples claves API para soportar diferentes proveedores simultáneamente:

docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OPENAI_API_KEY=sk-tu-clave-openai \
  -e ANTHROPIC_API_KEY=sk-ant-tu-clave-anthropic \
  -e GOOGLE_API_KEY=tu-clave-google-gemini \
  -e MISTRAL_API_KEY=tu-clave-mistral \
  -e ACCESS_CODE=tu-contraseña-secreta \
  lobehub/lobe-chat

---

Opción C: Con backend local Ollama

Si tienes Ollama ejecutándose en el mismo servidor Clore.ai (ver Guía de Ollama):

# Primero, inicia Ollama
docker run -d \
  --name ollama \
  --restart unless-stopped \
  --gpus all \
  -p 11434:11434 \
  -v ollama:/root/.ollama \
  ollama/ollama

# Descargar un modelo
docker exec ollama ollama pull llama3.2

# Iniciar LobeChat apuntando a Ollama
docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OLLAMA_PROXY_URL=http://host-gateway:11434 \
  --add-host=host-gateway:host-gateway \
  lobehub/lobe-chat

En Linux, reemplaza host-gateway con la IP real del puente Docker, típicamente 172.17.0.1:

-e OLLAMA_PROXY_URL=http://172.17.0.1:11434

---

Opción D: Modo Base de datos (Docker Compose)

El modo Base de datos habilita historial persistente de conversaciones, soporte multiusuario, subidas de archivos a almacenamiento compatible con S3 y una base de conocimientos completa.

Paso 1: Crear directorio del proyecto

mkdir -p ~/lobechat && cd ~/lobechat

Paso 2: Crear docker-compose.yml

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

services:
  postgresql:
    image: pgvector/pgvector:pg16
    container_name: lobe-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: lobechat
      POSTGRES_USER: lobechat
      POSTGRES_PASSWORD: cambialo_por_una_contraseña_fuerte
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U lobechat -d lobechat"]
      interval: 10s
      timeout: 5s
      retries: 5

  minio:
    image: minio/minio
    container_name: lobe-minio
    restart: unless-stopped
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: cambialo_por_la_contraseña_minio
    command: server /data --console-address ":9001"
    volumes:
      - minio_data:/data
    ports:
      - "9000:9000"
      - "9001:9001"

  lobechat:
    image: lobehub/lobe-chat-database
    container_name: lobe-chat
    restart: unless-stopped
    depends_on:
      postgresql:
        condition: service_healthy
    ports:
      - "3210:3210"
    environment:
      # Base de datos
      DATABASE_URL: postgresql://lobechat:cambialo_por_una_contraseña_fuerte@postgresql:5432/lobechat
      # Almacenamiento S3 (MinIO)
      S3_ENDPOINT: http://minio:9000
      S3_BUCKET: lobechat
      S3_ACCESS_KEY_ID: minioadmin
      S3_SECRET_ACCESS_KEY: cambialo_por_la_contraseña_minio
      S3_PUBLIC_DOMAIN: http://<tu-ip-servidor>:9000
      # Auth (NextAuth)
      NEXTAUTH_SECRET: tu-secreto-aleatorio-de-32-caracteres-aqui
      NEXTAUTH_URL: http://<tu-ip-servidor>:3210
      # Proveedores LLM
      OPENAI_API_KEY: sk-tu-clave-openai
      ANTHROPIC_API_KEY: sk-tu-clave-ant
      # App
      APP_URL: http://<tu-ip-servidor>:3210

volumes:
  postgres_data:
  minio_data:
EOF

Paso 3: Iniciar la pila

docker compose up -d
docker compose logs -f lobechat

Paso 4: Crear bucket en MinIO

# Instalar cliente MinIO
docker exec lobe-minio mc alias set local http://localhost:9000 minioadmin cambialo_por_la_contraseña_minio
docker exec lobe-minio mc mb local/lobechat
docker exec lobe-minio mc anonymous set download local/lobechat

---

Configuración

Referencia de variables de entorno

Variable	Descripción	Valor por defecto
OPENAI_API_KEY	Clave API de OpenAI	—
OPENAI_PROXY_URL	Punto final personalizado compatible con OpenAI	https://api.openai.com/v1
ANTHROPIC_API_KEY	Clave API de Anthropic Claude	—
GOOGLE_API_KEY	Clave API de Google Gemini	—
MISTRAL_API_KEY	Clave API de Mistral AI	—
OLLAMA_PROXY_URL	URL a la instancia local de Ollama	—
ACCESS_CODE	Contraseña para proteger la interfaz	—
DEFAULT_AGENT_CONFIG	Configuración JSON para el comportamiento predeterminado del asistente	—
FEATURE_FLAGS	Habilitar/deshabilitar funciones específicas	—

Habilitando funciones específicas

Habilitar complemento de búsqueda web:

-e BING_API_KEY=tu-clave-de-busqueda-bing

Habilitar texto a voz:

-e AZURE_TTS_API_KEY=tu-clave-azure \
-e AZURE_TTS_REGION=eastus

Establecer prompt de sistema personalizado para el agente predeterminado:

-e DEFAULT_AGENT_CONFIG='{"systemRole":"Eres un asistente servicial."}'

Actualizando LobeChat

# Descargar la imagen más reciente
docker pull lobehub/lobe-chat

# Detener y eliminar el contenedor antiguo
docker stop lobechat && docker rm lobechat

# Iniciar nuevo contenedor con los mismos parámetros
docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OPENAI_API_KEY=sk-tu-clave \
  lobehub/lobe-chat

Para Docker Compose:

docker compose pull
docker compose up -d

---

Aceleración por GPU

El propio LobeChat sí soportan requiere GPU. Sin embargo, cuando se combina con un backend acelerado por GPU en Clore.ai, obtienes inferencia local y privada de LLM:

Emparejamiento con vLLM (inferencia de alto rendimiento)

Ver el Guía de vLLM para la configuración completa. Integración rápida:

# Iniciar servidor vLLM (en el mismo host)
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-3.1-8B-Instruct \
  --served-model-name llama3.1-8b

# Iniciar LobeChat apuntando a vLLM (API compatible con OpenAI)
docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OPENAI_API_KEY=no-necesaria \
  -e OPENAI_PROXY_URL=http://172.17.0.1:8000/v1 \
  lobehub/lobe-chat

Uso de recursos

Backend	VRAM de GPU usada	Rendimiento aproximado
Ollama (Llama 3.2 3B)	~2 GB	50–80 tokens/seg en 3090
Ollama (Llama 3.1 8B)	~6 GB	40–60 tokens/seg en 3090
vLLM (Llama 3.1 8B)	~16 GB	80–150 tokens/seg en 3090
vLLM (Llama 3.1 70B)	~80 GB	20–40 tokens/seg en A100 80GB

---

Consejos y mejores prácticas

Optimización de costos

• Apaga tu servidor cuando esté inactivo. Clore.ai cobra por hora: usa el panel para pausar las instancias que no estés usando activamente.

• Modo independiente para uso personal. A menos que necesites soporte multiusuario o historial persistente del lado del servidor, el modo independiente evita la sobrecarga de PostgreSQL y MinIO.

• Usa proveedores de API para modelos grandes. Enrutear solicitudes a Claude o GPT-4 a través de APIs externas es más barato que alquilar una H100 para consultas ocasionales.

Seguridad

# Siempre establece un código de acceso en las IPs públicas de Clore.ai
-e ACCESS_CODE=tu-contraseña-fuerte-aqui

# Restringir a un origen específico (opcional)
-e NEXT_PUBLIC_SERVICE_MODE=server

• Nunca expongas LobeChat sin un ACCESS_CODE en una IP pública.

• Considera usar Nginx como proxy inverso con HTTPS si lo ejecutas a largo plazo.

• Rota las claves API si sospechas exposición.

Rendimiento

# Aumenta el heap de Node.js si ejecutas el modo base de datos con muchos usuarios
-e NODE_OPTIONS="--max-old-space-size=4096"

• Para el modo base de datos con 10+ usuarios concurrentes, asegúrate de al menos 8 GB de RAM en el host.

• MinIO funciona mejor con almacenamiento respaldado por SSD (instancias NVMe de Clore.ai).

Persistencia entre sesiones de Clore.ai

Dado que los servidores Clore.ai pueden terminarse:

# Crea un volumen Docker para exportaciones de conversaciones independientes
docker run -d \
  --name lobechat \
  -p 3210:3210 \
  -v lobechat_data:/app/data \
  lobehub/lobe-chat

Exporta regularmente conversaciones desde Configuración → Exportar datos en la UI.

---

Solución de problemas

El contenedor no se inicia

# Revisa los logs
docker logs lobechat --tail 50

# Verifica que el puerto no esté en uso
ss -tlnp | grep 3210

# Comprueba que el daemon de Docker esté en ejecución
systemctl status docker

No se puede conectar a Ollama desde LobeChat

# Prueba la conectividad desde el contenedor LobeChat
docker exec lobechat curl -s http://172.17.0.1:11434/api/tags

# Si eso falla, verifica que Ollama esté escuchando en todas las interfaces
docker exec ollama ollama serve --host 0.0.0.0

Errores de conexión a la base de datos (modo base de datos)

# Verifica la salud de PostgreSQL
docker exec lobe-postgres pg_isready -U lobechat

# Verifica el formato de DATABASE_URL
# postgresql://usuario:contraseña@host:puerto/nombre_bd

# Ejecuta migraciones manualmente si es necesario
docker exec lobe-chat npx prisma migrate deploy

Imágenes/archivos no se suben (modo base de datos)

# Verifica que MinIO sea accesible
curl -s http://localhost:9000/minio/health/live

# Verifica que el bucket exista
docker exec lobe-minio mc ls local/

# Comprueba que S3_PUBLIC_DOMAIN esté configurado con la IP correcta del servidor

Errores de falta de memoria

# Verifica el uso de memoria actual
docker stats lobechat

# Aumenta el límite de memoria del contenedor
docker run -d \
  --name lobechat \
  --memory=2g \
  -p 3210:3210 \
  lobehub/lobe-chat

---

Lecturas adicionales

• Documentación de LobeChat — documentación oficial, desarrollo de plugins, guías de despliegue

• LobeChat GitHub — código fuente, issues, discusiones

• Ejecutando Ollama en Clore.ai — backend LLM local para LobeChat

• Ejecutando vLLM en Clore.ai — inferencia de alto rendimiento compatible con OpenAI

• Guía de comparación de GPU — elegir la GPU correcta de Clore.ai

• LobeChat Docker Hub — etiquetas de imagen y versiones

• Variables de entorno de LobeChat — referencia completa de variables