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

# LibreChat multi proveedor

## Descripción general

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

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

* **Multi-proveedor real en una sola interfaz** — Cambia entre GPT-4, Claude 3.5, Gemini Pro, Mistral y modelos locales de Ollama durante la sesión.
* **No se necesita GPU para la aplicación** — LibreChat es una aplicación de Node.js; solo necesita capacidad de cómputo para la inferencia si conectas un backend local de LLM.
* **Autoalojamiento rentable** — Los precios de Clore.ai empiezan en fracciones de centavo por minuto, ideal para ejecutar un hub de IA personal.
* **Conversaciones persistentes** — MongoDB almacena todo tu historial de chat en el servidor, a diferencia de las soluciones locales del navegador.
* **Apto para equipos** — Compatibilidad 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 | Bifurca y explora respuestas alternativas                           |
| Complementos                   | Búsqueda de Bing, 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 sandbox aislado                                |
| Artefactos                     | Renderiza salidas HTML, React y Markdown                            |
| Preajustes                     | Guarda y comparte configuraciones personalizadas de modelos         |

***

## Requisitos

### Especificaciones del servidor

| Componente         | Mínimo         | Recomendado                  | Notas                                            |
| ------------------ | -------------- | ---------------------------- | ------------------------------------------------ |
| **GPU**            | No se requiere | RTX 3090 (si agregas Ollama) | Solo para inferencia local de LLM                |
| **VRAM**           | —              | 24 GB                        | Para modelos locales mediante 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 de RAM) | \~$0.05–0.10/h                            | LibreChat + proveedores API externos   |
| RTX 3090 (24 GB de VRAM)              | $0.07–0.21/h                              | LibreChat + inferencia local de Ollama |
| RTX 4090 (24 GB de VRAM)              | $0.14–0.42/h                              | LibreChat + Ollama/vLLM más rápidos    |
| A100 80 GB                            | [bare metal](https://clore.ai/bare-metal) | LibreChat + modelos grandes de 70B+    |

> 💡 **Consejo de coste:** Si solo usas LibreChat para enrutar llamadas API a OpenAI/Anthropic/Google, solo pagas por la capacidad de cómputo del servidor de Clore.ai (barata), no por el hardware de inferencia. Presupuesta unos $0.05–0.15/h para un host de LibreChat fiable.

### Requisitos previos

* Servidor de 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 de 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 ofrecer toda la funcionalidad.

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

```bash
ssh root@<la-ip-de-tu-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 — ajustes críticos
MONGO_URI=mongodb://mongodb:27017/LibreChat
JWT_SECRET=your-random-64-char-secret-here
JWT_REFRESH_SECRET=another-random-64-char-secret-here
CREDS_KEY=your-random-32-char-key-here
CREDS_IV=your-random-16-char-iv-here

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

Genera secretos rápidamente:

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

**Paso 4: inicia la pila**

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

Esto inicia:

* `LibreChat` — 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://<your-clore-server-ip>:3080
```

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

***

### Método 2: imagen Docker preconstruida (el más rápido)

Si quieres evitar compilar desde el código fuente:

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

# Descarga solo los archivos de 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 un solo contenedor

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=your-jwt-secret-here \
  -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 separada de MongoDB. Usa el Método 1 para una configuración completa.

***

## Configuración

### Añadir proveedores de IA

Editar `librechat.yaml` (créalo en la raíz del proyecto) para una 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:
    # Apunta a Ollama que se ejecuta en el mismo servidor de 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 hexadecimal aleatoria        |
| `OPENAI_API_KEY`     | Clave de OpenAI                                              | `sk-...`                            |
| `ANTHROPIC_API_KEY`  | Clave de Anthropic                                           | `sk-ant-...`                        |
| `GOOGLE_KEY`         | Clave de Google Gemini                                       | `IA...`                             |
| `ALLOW_REGISTRATION` | Habilitar registro público                                   | `true` / `false`                    |
| `ALLOW_EMAIL_LOGIN`  | Habilitar inicio de sesión con correo electrónico/contraseña | `true`                              |
| `DEBUG_LOGGING`      | Registros detallados                                         | `true`                              |
| `Búsqueda`           | 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 el intérprete de código

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

El intérprete de código ejecuta Python en un contenedor de 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 GPU

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

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

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

```bash
# Inicia Ollama con soporte de 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 con 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=your-hf-token \
  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 necesaria"
      baseURL: "http://172.17.0.1:8000/v1"
      models:
        default: ["meta-llama/Llama-3.1-70B-Instruct"]
        fetch: true
```

### Dimensionamiento de GPU para modelos locales

| Tamaño del modelo | VRAM mínima | GPU de Clore recomendada | Costo aprox.                              |
| ----------------- | ----------- | ------------------------ | ----------------------------------------- |
| 7–8B (Q4)         | 6 GB        | RTX 3090                 | $0.07–0.21/h                              |
| 13B (Q4)          | 10 GB       | RTX 3090                 | $0.07–0.21/h                              |
| 34B (Q4)          | 24 GB       | RTX 4090                 | $0.14–0.42/h                              |
| 70B (Q4)          | 48 GB       | 2× RTX 3090              | $0.14–0.42/h                              |
| 70B (FP16)        | 80 GB       | A100 80GB                | [bare metal](https://clore.ai/bare-metal) |

***

## Consejos y mejores prácticas

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

```bash
# Haz una instantánea 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 estén en uso
docker compose stop

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

### Estrategia de copias de seguridad

```bash
# Script automatizado de copia de seguridad diaria
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
# Conserva solo los últimos 7 días
find ~/backups -name "*.mongo.gz" -mtime +7 -delete
EOF

chmod +x /root/backup-librechat.sh
# Añádelo a crontab: 0 2 * * * /root/backup-librechat.sh
```

### Restaurar desde una copia de seguridad

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

### Asegurar LibreChat

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

### Proxy inverso de Nginx (opcional)

```bash
cat > /etc/nginx/sites-available/librechat << 'EOF'
server {
    listen 80;
    server_name your-domain.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

### El puerto 3080 no es accesible

```bash
# Comprueba si el contenedor está en ejecución
docker compose ps

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

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

# Comprueba el firewall de Clore.ai — asegúrate de que el puerto 3080 esté en tu asignación de puertos
```

### Conexión a MongoDB rechazada

```bash
# Comprueba 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
# Debería 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 de 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
```

### Los modelos de Ollama no aparecen

```bash
# Prueba la API de Ollama desde el contenedor de 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  # Comprueba en los registros de inicio la dirección de enlace
```

### Sin espacio en disco

```bash
# Comprueba el uso del disco
df -h
docker system df

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

# Comprueba el directorio de cargas de LibreChat
du -sh ~/LibreChat/client/public/uploads
```

### Actualizar a la versión más reciente

```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
* [GitHub de LibreChat](https://github.com/danny-avila/LibreChat) — código fuente, incidencias, registro de cambios
* [LibreChat en Docker Hub](https://ghcr.io/danny-avila/librechat-dev) — etiquetas de imagen
* [Ejecutar Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — backend local de LLM
* [Ejecutar 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
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/librechat.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.