> 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/lobechat.md).

# 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](https://github.com/lobehub/lobe-chat) 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](https://clore.ai/bare-metal) | LobeChat + modelos grandes (70B+)      |

> 💡 **Consejo:** Consulta [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) 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**

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

**Paso 2: Descarga y ejecuta LobeChat**

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

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

```bash
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](/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

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

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

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

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

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

**Paso 4: Crea el bucket de MinIO**

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

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

**Habilitar texto a voz:**

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

**Establece un prompt de sistema personalizado para el agente predeterminado:**

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

### Actualizando LobeChat

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

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

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

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

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

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

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

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

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

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

```bash
# 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](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, incidencias, debates
* [Ejecutar Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — backend LLM local para LobeChat
* [Ejecutar 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 de Clore.ai adecuada
* [LobeChat Docker Hub](https://hub.docker.com/r/lobehub/lobe-chat) — etiquetas y versiones de imagen
* [Variables de entorno de LobeChat](https://lobehub.com/docs/self-hosting/environment-variables) — referencia completa de variables


---

# 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/lobechat.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.