# LibreChat multivendor

## Resumen

[LibreChat](https://github.com/danny-avila/LibreChat) es una interfaz mejorada y de código abierto similar a ChatGPT con más de 22K estrellas en GitHub. Reimagina fielmente la experiencia de ChatGPT añadiendo funciones que el original no tiene: cambio entre múltiples proveedores dentro de la misma conversación, ramificación/forking de conversaciones, un sistema de plugins rico, cargas de archivos con visión y un sandbox completo de intérprete de código.

**¿Por qué ejecutar LibreChat en Clore.ai?**

* **Verdadero multi-proveedor en una sola interfaz** — Cambia entre GPT-4, Claude 3.5, Gemini Pro, Mistral y modelos locales de Ollama durante la misma sesión.
* **No se necesita GPU para la aplicación** — LibreChat es una aplicación Node.js; solo necesita cómputo para inferencia si conectas un backend LLM local.
* **Autoalojamiento rentable** — Los precios de Clore.ai comienzan en fracciones de centavo por minuto, ideal para ejecutar un hub de IA personal.
* **Conversaciones persistentes** — MongoDB almacena todo tu historial de chat del lado del servidor, a diferencia de las soluciones locales en el navegador.
* **Amigable para equipos** — Soporte multiusuario con gestión individual de claves API.

### Características clave

| Función                        | Descripción                                                    |
| ------------------------------ | -------------------------------------------------------------- |
| Multi-proveedor                | OpenAI, Anthropic, Google, Azure, Mistral, Ollama, OpenRouter  |
| Ramificación de conversaciones | Haz fork y explora respuestas alternativas                     |
| Plugins                        | Bing search, Zapier, WolframAlpha, herramientas personalizadas |
| Cargas de archivos             | Imágenes, PDFs, documentos con análisis de visión              |
| Intérprete de código           | Ejecuta Python en un contenedor aislado                        |
| Artefactos                     | Renderiza salidas HTML, React y Markdown                       |
| Preajustes                     | Guarda y comparte configuraciones de modelos personalizadas    |

***

## Requisitos

### Especificaciones del servidor

| Componente         | Mínimo            | Recomendado                 | Notas                                            |
| ------------------ | ----------------- | --------------------------- | ------------------------------------------------ |
| **GPU**            | Ninguna requerida | RTX 3090 (si añades Ollama) | Solo para inferencia LLM local                   |
| **VRAM**           | —                 | 24 GB                       | Para modelos locales vía Ollama                  |
| **CPU**            | 2 vCPU            | 4 vCPU                      | Node.js + MongoDB                                |
| **RAM**            | 4 GB              | 8 GB                        | MongoDB se beneficia de más RAM                  |
| **Almacenamiento** | 20 GB             | 50+ GB                      | Cargas de archivos, caché de modelos si es local |

### Referencia de precios de Clore.ai

| Tipo de servidor                   | Costo aprox.   | Caso de uso                             |
| ---------------------------------- | -------------- | --------------------------------------- |
| Enfocado en CPU (4 vCPU, 8 GB RAM) | \~$0.05–0.10/h | LibreChat + proveedores API externos    |
| RTX 3090 (24 GB VRAM)              | \~$0.20/h      | LibreChat + inferencia local con Ollama |
| RTX 4090 (24 GB VRAM)              | \~$0.35/h      | LibreChat + Ollama/vLLM más rápido      |
| A100 80 GB                         | \~$1.10/h      | LibreChat + modelos grandes de 70B+     |

> 💡 **Consejo de coste:** Si solo usas LibreChat para encaminar llamadas de API a OpenAI/Anthropic/Google, solo pagas por el cómputo del servidor Clore.ai (barato), no por el hardware de inferencia. Presupuesta \~0,05–0,15 USD/h para un host LibreChat confiable.

### Prerrequisitos

* Servidor Clore.ai con acceso SSH
* Docker + Docker Compose (preinstalado en Clore.ai)
* Git (preinstalado en Clore.ai)
* Al menos una clave API de LLM **o** un backend local Ollama/vLLM

***

## Inicio rápido

### Método 1: Docker Compose (Oficial — Recomendado)

El despliegue oficial de LibreChat usa Docker Compose con MongoDB y MeiliSearch para funcionalidad completa.

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

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

**Paso 2: Clona el repositorio**

```bash
git clone https://github.com/danny-avila/LibreChat.git
cd LibreChat
```

**Paso 3: Configura el entorno**

```bash
cp .env.example .env
nano .env
```

Configura como mínimo:

```bash
# En .env — configuraciones críticas
MONGO_URI=mongodb://mongodb:27017/LibreChat
JWT_SECRET=tu-secreto-aleatorio-de-64-caracteres-aquí
JWT_REFRESH_SECRET=otro-secreto-aleatorio-de-64-caracteres-aquí
CREDS_KEY=tu-clave-aleatoria-de-32-caracteres-aquí
CREDS_IV=tu-iv-aleatorio-de-16-caracteres-aquí

# Claves API (añade las que uses)
OPENAI_API_KEY=sk-tu-clave-openai
ANTHROPIC_API_KEY=sk-ant-tu-clave-anthropic
GOOGLE_KEY=tu-clave-google-gemini
```

Genera secretos rápidamente:

```bash
# Generar secretos aleatorios
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
```

**Paso 4: Inicia el stack**

```bash
docker compose up -d
```

Esto inicia:

* `LibreChat` — la aplicación principal en el puerto 3080
* `MongoDB` — almacenamiento de conversaciones y usuarios
* `MeiliSearch` — búsqueda rápida de conversaciones

**Paso 5: Verifica y accede**

```bash
docker compose ps
docker compose logs librechat --tail 30
```

Abre en el navegador:

```
http://<ip-de-tu-servidor-clore>:3080
```

Registra una nueva cuenta en la página de inicio de sesión.

***

### Método 2: Imagen Docker preconstruida (Más rápido)

Si quieres evitar construir desde la fuente:

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

# Descarga solo los archivos docker-compose
curl -o docker-compose.yml https://raw.githubusercontent.com/danny-avila/LibreChat/main/docker-compose.yml
curl -o .env https://raw.githubusercontent.com/danny-avila/LibreChat/main/.env.example

# Edita la configuración
nano .env

# Inicia
docker compose up -d
```

***

### Método 3: Prueba rápida en contenedor único

Para una prueba de concepto rápida sin MongoDB (funcionalidad limitada):

```bash
docker run -d \
  --name librechat \
  --restart unless-stopped \
  -p 3080:3080 \
  -e OPENAI_API_KEY=sk-tu-clave \
  -e JWT_SECRET=tu-secreto-jwt-aquí \
  -e MONGO_URI=mongodb://host-gateway:27017/LibreChat \
  --add-host=host-gateway:host-gateway \
  ghcr.io/danny-avila/librechat-dev:latest
```

> ⚠️ Este método requiere una instancia MongoDB separada. Usa el Método 1 para una configuración completa.

***

## Configuración

### Agregar proveedores de IA

Editar `librechat.yaml` (créalo en la raíz del proyecto) para configuración avanzada de proveedores:

```bash
cat > librechat.yaml << 'EOF'
version: 1.1.5
cache: true

endpoints:
  openAI:
    models:
      default: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo"]
      fetch: true

  anthropic:
    models:
      default: ["claude-opus-4-5", "claude-sonnet-4-5", "claude-3-haiku-20240307"]
      fetch: false

  google:
    models:
      default: ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-pro"]
      fetch: false

  ollama:
    # Señala a Ollama ejecutándose en el mismo servidor Clore.ai
    baseURL: http://host-gateway:11434/v1
    apiKey: ollama
    models:
      default: ["llama3.2", "mistral", "codellama"]
      fetch: true

  custom:
    - name: "OpenRouter"
      apiKey: "${OPENROUTER_API_KEY}"
      baseURL: "https://openrouter.ai/api/v1"
      models:
        default: ["meta-llama/llama-3.1-8b-instruct:free"]
        fetch: true
      titleConvo: true
      titleModel: "meta-llama/llama-3.1-8b-instruct:free"
EOF
```

Monta este archivo en tu `docker-compose.yml`:

```yaml
services:
  LibreChat:
    volumes:
      - ./librechat.yaml:/app/librechat.yaml
```

### Referencia de variables de entorno

| Variable             | Descripción                                     | Ejemplo                             |
| -------------------- | ----------------------------------------------- | ----------------------------------- |
| `MONGO_URI`          | Cadena de conexión de MongoDB                   | `mongodb://mongodb:27017/LibreChat` |
| `JWT_SECRET`         | Secreto de firma JWT (64+ caracteres)           | Cadena hex aleatoria                |
| `OPENAI_API_KEY`     | Clave OpenAI                                    | `sk-...`                            |
| `ANTHROPIC_API_KEY`  | Clave Anthropic                                 | `sk-ant-...`                        |
| `GOOGLE_KEY`         | Clave Google Gemini                             | `IA...`                             |
| `ALLOW_REGISTRATION` | Habilitar registro público                      | `true` / `false`                    |
| `ALLOW_EMAIL_LOGIN`  | Habilitar inicio de sesión por email/contraseña | `true`                              |
| `DEBUG_LOGGING`      | Registros detallados                            | `true`                              |
| `SEARCH`             | Habilitar MeiliSearch                           | `true`                              |
| `MEILI_MASTER_KEY`   | Clave API de MeiliSearch                        | Cadena aleatoria                    |

### Restringir el registro

Para uso privado, desactiva el registro público después de crear tu cuenta:

```bash
# En .env
ALLOW_REGISTRATION=false
```

Luego reinicia: `docker compose restart LibreChat`

### Habilitar Intérprete de Código

```bash
# En .env
CODE_INTERPRETER_ENABLED=true
```

El intérprete de código ejecuta Python en un contenedor Docker aislado. Asegúrate de que el socket de Docker sea accesible.

### Configuración de carga de archivos

```bash
# En .env
# Tamaño máximo de archivo en MB
FILE_UPLOAD_SIZE_LIMIT=100

# Habilitar cargas de imágenes para modelos de visión
VISION_ENABLED=true
```

***

## Aceleración por GPU

LibreChat no **soportan** usa GPU directamente — es una capa de enrutamiento. La aceleración por GPU aplica a cualquier backend de inferencia local que conectes.

### Conexión a Ollama (Mismo servidor)

Si ejecutas Ollama en el mismo servidor Clore.ai (ver [Guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md)):

```bash
# Inicia Ollama con soporte GPU
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_models:/root/.ollama \
  ollama/ollama

# Descargar modelos
docker exec ollama ollama pull llama3.2
docker exec ollama ollama pull codellama:13b

# En librechat.yaml, configura:
# baseURL: http://172.17.0.1:11434/v1
```

### Conexión a vLLM (Alto rendimiento)

Para despliegues de alta concurrencia (ver [Guía de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)):

```bash
# Inicia vLLM en una instancia A100 de Clore.ai
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  -v hf_cache:/root/.cache/huggingface \
  -e HF_TOKEN=tu-token-hf \
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-3.1-70B-Instruct \
  --tensor-parallel-size 2 \
  --max-model-len 8192
```

En `librechat.yaml`:

```yaml
  custom:
    - name: "Local vLLM"
      apiKey: "no-necesario"
      baseURL: "http://172.17.0.1:8000/v1"
      models:
        default: ["meta-llama/Llama-3.1-70B-Instruct"]
        fetch: true
```

### Dimensionamiento GPU para modelos locales

| Tamaño del modelo | VRAM mínima | GPU Clore recomendada | Costo aprox. |
| ----------------- | ----------- | --------------------- | ------------ |
| 7–8B (Q4)         | 6 GB        | RTX 3090              | \~$0.20/h    |
| 13B (Q4)          | 10 GB       | RTX 3090              | \~$0.20/h    |
| 34B (Q4)          | 24 GB       | RTX 4090              | \~$0.35/h    |
| 70B (Q4)          | 48 GB       | 2× RTX 3090           | \~0,40 USD/h |
| 70B (FP16)        | 80 GB       | A100 80GB             | \~$1.10/h    |

***

## Consejos y mejores prácticas

### Gestión de costos en Clore.ai

```bash
# Haz snapshot de tu configuración antes de detener el servidor
docker compose exec mongodb mongodump --out /tmp/backup
docker cp librechat-mongodb-1:/tmp/backup ./mongo-backup-$(date +%Y%m%d)

# Detén todos los contenedores cuando no se usen
docker compose stop

# O reduce a costo cero pausando la instancia Clore.ai desde el panel
```

### Estrategia de backups

```bash
# Script de respaldo diario automatizado
cat > /root/backup-librechat.sh << 'EOF'
#!/bin/bash
cd ~/LibreChat
docker compose exec -T mongodb mongodump --archive | \
  gzip > ~/backups/librechat-$(date +%Y%m%d-%H%M).mongo.gz
# Mantener solo los últimos 7 días
find ~/backups -name "*.mongo.gz" -mtime +7 -delete
EOF

chmod +x /root/backup-librechat.sh
# Añadir al crontab: 0 2 * * * /root/backup-librechat.sh
```

### Restaurar desde backup

```bash
# Restaurar volcado de MongoDB
gunzip < ~/backups/librechat-20240101-0200.mongo.gz | \
  docker compose exec -T mongodb mongorestore --archive
```

### Asegurando LibreChat

* Siempre establece valores fuertes y únicos para `JWT_SECRET` y `CREDS_KEY`
* Deshabilita el registro después de la creación del usuario inicial: `ALLOW_REGISTRATION=false`
* Usa un proxy inverso (nginx/Caddy) con HTTPS para producción
* Actualiza regularmente la imagen Docker: `docker compose pull && docker compose up -d`

### Proxy inverso Nginx (Opcional)

```bash
cat > /etc/nginx/sites-available/librechat << 'EOF'
server {
    listen 80;
    server_name tu-dominio.com;

    location / {
        proxy_pass http://localhost:3080;
        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;
        client_max_body_size 100M;
    }
}
EOF
ln -s /etc/nginx/sites-available/librechat /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx
```

***

## Solución de problemas

### Puerto 3080 no accesible

```bash
# Verifica si el contenedor está ejecutándose
docker compose ps

# Verifica el enlace del puerto
ss -tlnp | grep 3080

# Ver registros de la aplicación
docker compose logs librechat --tail 50 -f

# Verifica el firewall de Clore.ai — asegúrate de que el puerto 3080 esté en tu mapeo de puertos
```

### Conexión a MongoDB rechazada

```bash
# Verifica el estado de MongoDB
docker compose ps mongodb
docker compose logs mongodb --tail 20

# Verifica que MONGO_URI en .env coincida con el nombre del servicio
# Debe ser: mongodb://mongodb:27017/LibreChat (no localhost)

# Prueba la conexión manualmente
docker compose exec LibreChat node -e "
const mongoose = require('mongoose');
mongoose.connect(process.env.MONGO_URI)
  .then(() => console.log('Connected!'))
  .catch(e => console.error(e));
"
```

### Errores JWT / Autenticación

```bash
# Regenera secretos en .env
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

# Actualiza JWT_SECRET y JWT_REFRESH_SECRET
# Luego reinicia: docker compose restart LibreChat
```

### Modelos Ollama no aparecen

```bash
# Prueba la API de Ollama desde el contenedor LibreChat
docker compose exec LibreChat \
  curl -s http://172.17.0.1:11434/v1/models | python3 -m json.tool

# Asegúrate de que Ollama esté escuchando en 0.0.0.0, no solo en localhost
docker exec ollama ollama serve  # Verifica los logs de inicio para la dirección de enlace
```

### Sin espacio en disco

```bash
# Verifica el uso de disco
df -h
docker system df

# Limpia recursos de Docker
docker system prune -f
docker volume prune -f  # ADVERTENCIA: elimina volúmenes no usados

# Verifica el directorio de subidas de LibreChat
du -sh ~/LibreChat/client/public/uploads
```

### Actualiza a la última versión

```bash
cd ~/LibreChat
git pull origin main
docker compose pull
docker compose up -d --build
```

***

## Lecturas adicionales

* [Documentación de LibreChat](https://docs.librechat.ai) — referencia completa de configuración
* [LibreChat GitHub](https://github.com/danny-avila/LibreChat) — código fuente, issues, changelog
* [LibreChat Docker Hub](https://ghcr.io/danny-avila/librechat-dev) — etiquetas de imagen
* [Ejecutando Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — backend LLM local
* [Ejecutando vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — inferencia de alto rendimiento
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — elegir el nivel de GPU adecuado
* [Referencia del archivo de configuración de LibreChat](https://docs.librechat.ai/install/configuration/librechat_yaml.html) — `librechat.yaml` esquema


---

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