# Asistente de IA LobeChat

## Resumen

[LobeChat](https://github.com/lobehub/lobe-chat) 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](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) 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**

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

**Paso 2: Descargar y ejecutar LobeChat**

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

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

```bash
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](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md)):

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

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

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

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

```bash
docker compose up -d
docker compose logs -f lobechat
```

**Paso 4: Crear bucket en MinIO**

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

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

**Habilitar texto a voz:**

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

**Establecer prompt de sistema personalizado para el agente predeterminado:**

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

### Actualizando LobeChat

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

```bash
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](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) para la configuración completa. Integración rápida:

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

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

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

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

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

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

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

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

```bash
# 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](https://lobehub.com/docs) — documentación oficial, desarrollo de plugins, guías de despliegue
* [LobeChat GitHub](https://github.com/lobehub/lobe-chat) — código fuente, issues, discusiones
* [Ejecutando Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — backend LLM local para LobeChat
* [Ejecutando vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — inferencia de alto rendimiento compatible con OpenAI
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — elegir la GPU correcta de Clore.ai
* [LobeChat Docker Hub](https://hub.docker.com/r/lobehub/lobe-chat) — etiquetas de imagen y versiones
* [Variables de entorno de LobeChat](https://lobehub.com/docs/self-hosting/environment-variables) — referencia completa de variables


---

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

```
GET https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/lobechat.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.