LibreChat Multi-Proveedor

Despliega LibreChat en Clore.ai — una alternativa potente de ChatGPT autohospedada con soporte multi-proveedor de IA, ramificación de conversaciones y ecosistema de plugins en infraestructura de nube con GPU asequible.

Resumen

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

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

Paso 2: Clona el repositorio

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

Paso 3: Configura el entorno

cp .env.example .env
nano .env

Configura como mínimo:

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

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

Paso 4: Inicia el stack

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

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:

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):

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:

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:

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:

# En .env
ALLOW_REGISTRATION=false

Luego reinicia: docker compose restart LibreChat

Habilitar Intérprete de Código

# 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

# 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):

# 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):

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

  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

# 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

# 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

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

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

# 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

# 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

# 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

# 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

# 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

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

---

Lecturas adicionales

• Documentación de LibreChat — referencia completa de configuración

• LibreChat GitHub — código fuente, issues, changelog

• LibreChat Docker Hub — etiquetas de imagen

• Ejecutando Ollama en Clore.ai — backend LLM local

• Ejecutando vLLM en Clore.ai — inferencia de alto rendimiento

• Guía de comparación de GPU — elegir el nivel de GPU adecuado

• Referencia del archivo de configuración de LibreChat — librechat.yaml esquema