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

# 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](https://github.com/janhq/jan) 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](https://github.com/janhq/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

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

### 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](https://clore.ai/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](https://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

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

```bash
# 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

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

```yaml
# /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
```

```bash
# 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

```bash
# 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

```bash
# 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

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

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

O para dedicar GPU específicas:

```bash
# 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

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

```bash
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:

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

```bash
# 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

```bash
# 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

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

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

```bash
# 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

```bash
# 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

```bash
# 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

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

```bash
# 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

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

```bash
# 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](https://jan.ai/docs) — Documentación completa de la plataforma
* [Repositorio de GitHub de Jan](https://github.com/janhq/jan) — Código fuente y problemas
* [Jan Server / Jan API](https://github.com/janhq/jan-server) — Documentación específica del servidor
* [Motor Cortex.cpp](https://github.com/janhq/cortex.cpp) — El motor de inferencia subyacente
* [Primeros pasos con Clore.ai](/guides/guides_v2-es/primeros-pasos/getting-started.md) — Conceptos básicos de la plataforma
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — Elige la GPU adecuada
* [Ejecutar Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Servidor LLM alternativo
* [Ejecutar vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — Servidor de inferencia de alto rendimiento
* [Hugging Face Model Hub](https://huggingface.co/models?library=gguf) — 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](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)) en una A100.


---

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