Asistente offline Jan.ai

Despliega Jan.ai Server en Clore.ai: un servidor LLM totalmente offline y compatible con OpenAI, con centro de modelos, gestión de conversaciones e inferencia acelerada por GPU impulsada por el motor Cortex.

Descripción general

Jan.ai es una alternativa de ChatGPT de código abierto y centrada en la privacidad, con más de 40.000 estrellas en GitHub. Aunque Jan es más conocido como aplicación de escritorio, su componente de servidor — Servidor Jan — expone una API REST totalmente compatible con OpenAI que puede desplegarse en infraestructura de GPU en la nube como Clore.ai.

Jan Server está construido sobre el Cortex.cpp motor de inferencia, un entorno de ejecución de alto rendimiento que admite llama.cpp, TensorRT-LLM, y backends de ONNX. En Clore.ai puedes alquilar un servidor con GPU por tan solo $0.20/hr, ejecutar Jan Server con Docker Compose, cargar cualquier modelo GGUF o GPTQ y ofrecerlo mediante una API compatible con OpenAI, todo sin que tus datos abandonen la máquina.

Características principales:

• 🔒 100% sin conexión — ningún dato sale nunca de tu servidor

• 🤖 API compatible con OpenAI (/v1/chat/completions, /v1/models, etc.)

• 📦 Centro de modelos con descargas de modelos en un solo comando

• 🚀 Aceleración por GPU mediante CUDA (backends llama.cpp + TensorRT-LLM)

• 💬 Gestión de conversaciones y historial de hilos integrados

• 🔌 Reemplazo directo de OpenAI en aplicaciones existentes

---

Requisitos

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

Requisitos de hardware

Nivel	GPU	VRAM	RAM	Almacenamiento	Precio de Clore.ai
Mínimo	RTX 3060 12GB	12 GB	16 GB	SSD de 50 GB	$0.03–0.07/h
Recomendado	RTX 3090	24 GB	32 GB	SSD de 100 GB	$0.07–0.21/h
Gama alta	RTX 4090	24 GB	64 GB	SSD de 200 GB	$0.14–0.42/h
Modelos grandes	A100 80GB	80 GB	128 GB	SSD de 500 GB	bare metal

Referencia de VRAM de modelos

Modelo	VRAM requerida	GPU recomendada
Llama 3.1 8B (Q4)	~5 GB	RTX 3060
Llama 3.1 8B (FP16)	~16 GB	RTX 3090
Llama 3.3 70B (Q4)	~40 GB	A100 40GB
Llama 3.1 405B (Q4)	~220 GB	4× A100 80GB
Mistral 7B (Q4)	~4 GB	RTX 3060
Qwen2.5 72B (Q4)	~45 GB	A100 80GB

Requisitos de software

• Cuenta de Clore.ai con saldo en la cartera

• Conocimientos básicos de Docker

• (Opcional) Cliente OpenSSH para reenvío de puertos

---

Inicio rápido

Paso 1 — Alquila un servidor GPU en Clore.ai

1. Navega a clore.ai e inicia sesión

2. Filtrar servidores: Tipo de GPU → RTX 3090 o mejor, Docker → habilitado

3. Selecciona un servidor y elige la Docker opción de despliegue

4. Usa la nvidia/cuda:12.8.1-devel-ubuntu22.04 imagen base oficial o cualquier imagen CUDA

5. Abrir puertos: 1337 (API de Jan Server), 39281 (API de Cortex), 22 (SSH)

Paso 2 — Conéctate a tu servidor

# Conéctate por SSH a tu servidor de Clore.ai
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Verifica que la GPU esté disponible
nvidia-smi

Paso 3 — Instala Docker Compose (si no está presente)

# Comprueba si Docker Compose está disponible
docker compose version

# Instálalo si falta (Ubuntu/Debian)
apt-get update && apt-get install -y docker-compose-plugin

# Verificar
docker compose version

Paso 4 — Despliega Jan Server con Docker Compose

# Crea el directorio de trabajo
mkdir -p /workspace/jan-server && cd /workspace/jan-server

# Descarga el docker-compose.yml oficial de Jan Server
curl -fsSL https://raw.githubusercontent.com/janhq/jan-server/main/docker-compose.yml \
  -o docker-compose.yml

# Revisa y edita la configuración
cat docker-compose.yml

Si el archivo compose upstream no está disponible o quieres control total, créalo manualmente:

# /workspace/jan-server/docker-compose.yml
version: '3.8'

services:
  jan-server:
    image: ghcr.io/janhq/cortex:latest
    container_name: jan-server
    restart: unless-stopped
    ports:
      - "1337:1337"
      - "39281:39281"
    volumes:
      - jan-data:/root/jan
      - jan-models:/root/cortex/models
    environment:
      - CUDA_VISIBLE_DEVICES=0
      - JAN_API_HOST=0.0.0.0
      - JAN_API_PORT=1337
      - CORTEX_API_PORT=39281
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:1337/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

volumes:
  jan-data:
    driver: local
  jan-models:
    driver: local

# Inicia Jan Server
docker compose up -d

# Sigue los registros de arranque (espera el mensaje "Server started")
docker compose logs -f jan-server

Paso 5 — Verifica que el servidor esté en ejecución

# Comprobar la salud del servidor
curl http://localhost:1337/health

# Lista los modelos disponibles (inicialmente vacío)
curl http://localhost:1337/v1/models

# Respuesta esperada:
# {"object":"list","data":[]}

Paso 6 — Descarga tu primer modelo

# Descarga Llama 3.2 3B (buen punto de partida, ~2GB)
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \\
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# O descarga Mistral 7B Instruct Q4
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \\
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

# Monitoriza el progreso de la descarga
curl http://localhost:1337/v1/models

Paso 7 — Inicia el modelo y chatea

# Inicia el modelo (lo carga en la VRAM de la GPU)
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \\
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Envía tu primera solicitud de chat
curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "messages": [
      {"role": "system", "content": "Eres un asistente útil."},
      {"role": "user", "content": "Hello! What can you help me with?"}
    ],
    "temperature": 0.7,
    "max_tokens": 512,
    "stream": false
  }'

---

Configuración

Variables de entorno

Variable	Valor predeterminado	Descripción
JAN_API_HOST	0.0.0.0	Host al que enlazar el servidor de la API
JAN_API_PORT	1337	Puerto de la API de Jan Server
CORTEX_API_PORT	39281	Puerto interno del motor Cortex
CUDA_VISIBLE_DEVICES	all	Qué GPU exponer (índices separados por comas)
JAN_DATA_FOLDER	/root/jan	Ruta a la carpeta de datos de Jan
CORTEX_MODELS_PATH	/root/cortex/models	Ruta para almacenar los modelos

Configuración multi-GPU

Para servidores con varias GPU (por ejemplo, 2× RTX 3090 en Clore.ai):

environment:
  - CUDA_VISIBLE_DEVICES=0,1  # Usa ambas GPU

O para dedicar GPU específicas:

# Ejecuta Jan Server solo en la GPU 0
docker run -d \\
  --name jan-server \
  --gpus '"device=0"' \
  -p 1337:1337 \
  -v jan-data:/root/jan \
  -v jan-models:/root/cortex/models \
  ghcr.io/janhq/cortex:latest

Configuración personalizada del modelo

# Lista todos los modelos descargados
curl http://localhost:1337/v1/models | jq '.data[].id'

# Obtén detalles del modelo
curl http://localhost:1337/v1/models/llama3.2:3b-gguf-q4-km

# Detén un modelo en ejecución (libera VRAM)
curl -X POST http://localhost:1337/v1/models/stop \
  -H "Content-Type: application/json" \\
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Elimina un modelo (libera espacio en disco)
curl -X DELETE http://localhost:1337/v1/models/llama3.2:3b-gguf-q4-km

Asegurar la API con un token

Jan Server no incluye autenticación por defecto. Usa Nginx como proxy inverso:

apt-get install -y nginx apache2-utils

# Crea el archivo de contraseña
htpasswd -c /etc/nginx/.htpasswd admin

# Configura Nginx
cat > /etc/nginx/sites-available/jan-server << 'EOF'
server {
    listen 80;
    server_name _;

    location / {
        auth_basic "Jan Server";
        auth_basic_user_file /etc/nginx/.htpasswd;
        proxy_pass http://127.0.0.1:1337;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 300s;
    }
}
EOF

ln -s /etc/nginx/sites-available/jan-server /etc/nginx/sites-enabled/
nginx -t && systemctl restart nginx

---

Aceleración GPU

Verificando la aceleración CUDA

El motor Cortex de Jan Server detecta CUDA automáticamente. Verifica que esté usando la GPU:

# Comprueba el uso de memoria de la GPU después de cargar un modelo
nvidia-smi

# Debería mostrar que el proceso de cortex consume VRAM
# Ejemplo de salida:
# | Procesos:                                                            |
# |  GPU   GI   CI        PID   Tipo   Nombre del proceso    Memoria GPU |
# |    0    N/A  N/A    12345    C   /usr/local/bin/cortex    8192MiB |

Cambiando de backend de inferencia

Cortex admite múltiples backends:

# Comprueba qué backends están disponibles dentro del contenedor
docker exec jan-server cortex engines list

# Usa el backend TensorRT-LLM para GPUs NVIDIA (más rápido, requiere más configuración)
docker exec jan-server cortex engines install tensorrt-llm

# Usa el backend llama.cpp (predeterminado, el más compatible)
docker exec jan-server cortex engines install llama-cpp

Ajuste de la ventana de contexto y del tamaño de lote

# Personaliza los parámetros del modelo para el rendimiento de la GPU
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "ctx_len": 8192,
    "ngl": 99,
    "n_batch": 512,
    "n_parallel": 4,
    "cpu_threads": 8
  }'

Parámetro	Descripción	Recomendación
ngl	Capas de GPU (más alto = más uso de GPU)	Establécelo en 99 para exprimir al máximo la GPU
ctx_len	Tamaño de la ventana de contexto	4096–32768 según la VRAM
n_batch	Tamaño de lote para el procesamiento del prompt	512 para RTX 3090, 256 para tarjetas más pequeñas
n_parallel	Ranuras de solicitudes simultáneas	4–8 para uso del servidor API

---

Consejos y mejores prácticas

🎯 Selección de modelo para presupuestos de Clore.ai

# Nivel de presupuesto ($0.03–0.07/hr, RTX 3060 12GB):
# Usa cuantizaciones Q4_K_M de modelos de 7B
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

# Nivel estándar ($0.07–0.21/hr, RTX 3090 24GB):
# Usa cuantizaciones Q5_K_M de modelos de 13B o Q4 de 30B
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.1:8b-instruct-gguf-q5-km"}'

# Nivel de gama alta ([bare metal](https://clore.ai/bare-metal), A100 80GB):
# Ejecuta modelos completos de 70B con alta precisión
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.3:70b-instruct-gguf-q4-km"}'

💾 Almacenamiento persistente de modelos

Como las instancias de Clore.ai son efímeras, considera montar almacenamiento externo:

# Usa un volumen con nombre (persiste con Docker)
docker compose down
# Los modelos permanecen en el volumen con nombre 'jan-models'

# Para un almacenamiento verdaderamente persistente entre instancias,
# sube los modelos a almacenamiento de objetos y descárgalos al iniciar:
cat > /workspace/startup.sh << 'EOF'
#!/bin/bash
docker compose up -d
sleep 30
# Precarga tus modelos usados con frecuencia
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \\
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'
EOF
chmod +x /workspace/startup.sh

🔗 Usar Jan Server como sustituto de OpenAI

# Python — usa las bibliotecas cliente de OpenAI existentes
from openai import OpenAI

client = OpenAI(
    base_url="http://<CLORE_IP>:1337/v1",
    api_key="not-required"  # Jan Server no tiene autenticación por defecto
)

response = client.chat.completions.create(
    model="llama3.2:3b-gguf-q4-km",
    messages=[{"role": "user", "content": "Explain quantum computing"}],
    temperature=0.7
)
print(response.choices[0].message.content)

# Compatibilidad con streaming
curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "messages": [{"role": "user", "content": "Write a haiku about GPUs"}],
    "stream": true
  }'

📊 Supervisión del uso de recursos

# Vigila la utilización de la GPU en tiempo real
watch -n 1 nvidia-smi

# Comprueba el uso de recursos del contenedor
docker stats jan-server

# Ver registros detallados
docker compose logs --tail=100 jan-server

# Comprueba los tiempos de carga del modelo
docker compose logs jan-server | grep -E "(loaded|started|error)"

---

Solución de problemas

El contenedor no arranca — no se encontró la GPU

# Verifica que el runtime de NVIDIA Docker esté configurado
docker info | grep -i nvidia

# Prueba el acceso a la GPU directamente
docker run --rm --gpus all nvidia/cuda:12.8.1-base-ubuntu22.04 nvidia-smi

# Si esto falla, comprueba la configuración del daemon de Docker
cat /etc/docker/daemon.json
# Debería contener: {"runtimes": {"nvidia": {...}}}

La descarga del modelo se queda atascada o falla

# Comprobar el espacio en disco
df -h /root

# Comprueba los registros del contenedor en busca de errores
docker compose logs jan-server | tail -50

# Reintenta la descarga
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \\
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

Sin VRAM (memoria CUDA insuficiente)

# Comprueba el uso actual de VRAM
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# Detén primero todos los modelos en ejecución
curl http://localhost:1337/v1/models | jq -r '.data[].id' | while read model; do
  curl -X POST http://localhost:1337/v1/models/stop \
    -H "Content-Type: application/json" \\
    -d "{\"model\": \"$model\"}"
done

# Usa un modelo con cuantización más agresiva (Q3 o Q4 en lugar de Q8)
# Q4_K_M normalmente usa ~50% del requisito de VRAM de Q8

No se puede conectar a la API desde fuera del contenedor

# Asegúrate de que el puerto 1337 esté enlazado en todas las interfaces
docker ps --format "table {{.Names}}\t{{.Ports}}"
# Debería mostrar: 0.0.0.0:1337->1337/tcp

# Revisa las reglas del firewall de Clore.ai — abre el puerto 1337 en la configuración del servidor
# Prueba primero de forma local:
curl http://127.0.0.1:1337/health

# Luego prueba desde fuera:
curl http://<CLORE_SERVER_IP>:<MAPPED_PORT>/health

Inferencia lenta (retroceso a CPU)

# Confirma que se está usando CUDA (no CPU)
docker exec jan-server cortex ps
# Debería mostrar memoria de GPU asignada

# Fuerza las capas de GPU al iniciar el modelo
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \\
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km", "ngl": 99}'

---

Lecturas adicionales

• Documentación oficial de Jan.ai — Documentación completa de la plataforma

• Repositorio de GitHub de Jan — Código fuente y problemas

• Jan Server / Jan API — Documentación específica del servidor

• Motor Cortex.cpp — El motor de inferencia subyacente

• Primeros pasos con Clore.ai — Conceptos básicos de la plataforma

• Guía de comparación de GPU — Elige la GPU adecuada

• Ejecutar Ollama en Clore.ai — Servidor LLM alternativo

• Ejecutar vLLM en Clore.ai — Servidor de inferencia de alto rendimiento

• Hugging Face Model Hub — Encuentra modelos GGUF

💡 Consejo de costo: Una RTX 3090 en Clore.ai ($0.07–0.21/hr) puede ejecutar Llama 3.1 8B a ~50 tokens/second — suficiente para uso personal o APIs de poco tráfico. Para cargas de trabajo de producción, considera vLLM (ver guía de vLLM) en una A100.