Asistente de IA LobeChat

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

Descripción general

LobeChat LobeChat es un marco moderno y de código abierto para chat con IA, con más de 55 mil estrellas en GitHub, conocido por su interfaz pulida y su amplio conjunto de funciones. Es compatible prácticamente con todos los principales proveedores de LLM: OpenAI, Anthropic Claude, Google Gemini, Mistral y modelos locales mediante Ollama, todo desde una única interfaz autoalojada.

¿Por qué ejecutar LobeChat en Clore.ai?

• No se requiere GPU — LobeChat en sí 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.

• Combínalo con LLM locales — Inicia Ollama o vLLM en el mismo servidor de Clore.ai y apunta LobeChat hacia él para una inferencia totalmente local y privada.

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

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

LobeChat funciona en dos modos distintos:

Modo	Descripción	Ideal para
Independiente	Un solo contenedor Docker, la configuración se guarda en el navegador	Pruebas rápidas, uso personal
Base de datos	Stack completo (PostgreSQL + MinIO + autenticación + aplicación)	Equipos, historial persistente, base de conocimientos

---

Requisitos

Especificaciones del servidor

Componente	Mínimo	Recomendado	Notas
GPU	No se requiere	RTX 3090 (si ejecutas LLM locales)	Solo necesario para el backend Ollama/vLLM
VRAM	—	24 GB (RTX 3090)	Para la inferencia de modelos locales
CPU	2 vCPU	4+ vCPU	LobeChat en sí es ligero
RAM	2 GB	8 GB	4+ GB si usas el modo de base de datos
Almacenamiento	10 GB	50+ GB	Más si almacenas archivos cargados 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 de VRAM)	$0.07–0.21/h	LobeChat + LLM locales con Ollama
RTX 4090 (24 GB de VRAM)	$0.14–0.42/h	LobeChat + inferencia local más rápida
A100 80 GB	bare metal	LobeChat + modelos grandes (70B+)

💡 Consejo: Consulta Guía de comparación de GPU para más detalles.

Requisitos previos

• Cuenta de Clore.ai con un servidor desplegado

• Acceso SSH a tu servidor

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

• Controladores NVIDIA (preinstalados; solo relevantes si usas un 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 de Clore.ai

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

Paso 2: Descarga y ejecuta LobeChat

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

Paso 3: Verifica que esté en ejecución

docker ps
docker logs lobechat --tail 20

Paso 4: Accede a la interfaz

Abre tu navegador y navega a:

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

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

---

Opción B: Modo independiente con varios proveedores

Pasa varias claves API para admitir distintos proveedores simultáneamente:

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

---

Opción C: Con backend local de Ollama

Si tienes Ollama ejecutándose en el mismo servidor de Clore.ai (consulta 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

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

# Inicia 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 de Docker, normalmente 172.17.0.1:

-e OLLAMA_PROXY_URL=http://172.17.0.1:11434

---

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

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

Paso 1: Crea el directorio del proyecto

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

Paso 2: Crear docker-compose.yml

cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  postgresql:
    image: pgvector/pgvector:pg16
    container_name: lobe-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: lobechat
      POSTGRES_USER: lobechat
      POSTGRES_PASSWORD: changeme_strong_password
    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: changeme_minio_password
    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:changeme_strong_password@postgresql:5432/lobechat
      # Almacenamiento S3 (MinIO)
      S3_ENDPOINT: http://minio:9000
      S3_BUCKET: lobechat
      S3_ACCESS_KEY_ID: minioadmin
      S3_SECRET_ACCESS_KEY: changeme_minio_password
      S3_PUBLIC_DOMAIN: http://<tu-ip-del-servidor>:9000
      # Autenticación (NextAuth)
      NEXTAUTH_SECRET: tu-secreto-aleatorio-de-32-caracteres-aquí
      NEXTAUTH_URL: http://<tu-ip-del-servidor>:3210
      # Proveedores de LLM
      OPENAI_API_KEY: sk-tu-clave-de-openai
      ANTHROPIC_API_KEY: sk-ant-tu-clave
      # Aplicación
      APP_URL: http://<tu-ip-del-servidor>:3210

volumes:
  postgres_data:
  minio_data:
EOF

Paso 3: Inicia el stack

docker compose up -d
docker compose logs -f lobechat

Paso 4: Crea el bucket de MinIO

# Instala el cliente de MinIO
docker exec lobe-minio mc alias set local http://localhost:9000 minioadmin changeme_minio_password
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 predeterminado
OPENAI_API_KEY	Clave API de OpenAI	—
OPENAI_PROXY_URL	Punto de conexión 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 de 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 el complemento de búsqueda web:

-e BING_API_KEY=tu-clave-de-búsqueda-bing

Habilitar texto a voz:

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

Establece un prompt de sistema personalizado para el agente predeterminado:

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

Actualizando LobeChat

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

# Detén y elimina el contenedor anterior
docker stop lobechat && docker rm lobechat

# Inicia un 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 GPU

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

Combinación con vLLM (inferencia de alto rendimiento)

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

# Inicia el 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

# Inicia 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 utilizada	Rendimiento aproximado
Ollama (Llama 3.2 3B)	~2 GB	50–80 tokens/s en 3090
Ollama (Llama 3.1 8B)	~6 GB	40–60 tokens/s en 3090
vLLM (Llama 3.1 8B)	~16 GB	80–150 tokens/s en 3090
vLLM (Llama 3.1 70B)	~80 GB	20–40 tokens/s en A100 de 80 GB

---

Consejos y mejores prácticas

Optimización de costos

• Detén 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. Enrutar las solicitudes de Claude o GPT-4 a través de APIs externas es más barato que alquilar un H100 para consultas ocasionales.

Seguridad

# Establece siempre un código de acceso en IP públicas de Clore.ai
-e ACCESS_CODE=tu-contraseña-segura-aquí

# 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 un proxy inverso Nginx con HTTPS si va a ejecutarse a largo plazo.

• Rota las claves API si sospechas de una exposición.

Rendimiento

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

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

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

Persistencia entre sesiones de Clore.ai

Dado que los servidores de Clore.ai pueden terminarse:

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

Exporta regularmente las conversaciones desde Configuración → Exportación de datos en la interfaz.

---

Solución de problemas

El contenedor no inicia

# Ver registros
docker logs lobechat --tail 50

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

# Comprueba que el demonio Docker está en ejecución
systemctl status docker

No se puede conectar a Ollama desde LobeChat

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

# Si eso falla, comprueba 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 de base de datos)

# Comprueba el estado de PostgreSQL
docker exec lobe-postgres pg_isready -U lobechat

# Verifica el formato de DATABASE_URL
# postgresql://user:password@host:port/dbname

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

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

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

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

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

Errores de memoria insuficiente

# Comprueba el uso actual de memoria
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, incidencias, debates

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

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

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

• LobeChat Docker Hub — etiquetas y versiones de imagen

• Variables de entorno de LobeChat — referencia completa de variables