LibreChat multi proveedor

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

Descripción general

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

ssh root@<la-ip-de-tu-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 — 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:

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

Paso 4: inicia la pila

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

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:

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

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:

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:

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:

# En .env
ALLOW_REGISTRATION=false

Luego reinicia: docker compose restart LibreChat

Habilitar el intérprete de código

# 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

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

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

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

  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

---

Consejos y mejores prácticas

Gestión de costes en Clore.ai

# 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

# 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

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

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

# 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

# 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

# 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

# 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

# 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

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

• GitHub de LibreChat — código fuente, incidencias, registro de cambios

• LibreChat en Docker Hub — etiquetas de imagen

• Ejecutar Ollama en Clore.ai — backend local de LLM

• Ejecutar 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