# Офлайн-ассистент Jan.ai

## Обзор

[Jan.ai](https://github.com/janhq/jan) является проектом с открытым исходным кодом и приоритетом конфиденциальности, альтернативой ChatGPT с более чем 40 000 звёзд на GitHub. Хотя Jan наиболее известен как десктопное приложение, его серверный компонент — **Jan Server** — предоставляет полностью совместимый с OpenAI REST API, который можно развернуть на облачной GPU-инфраструктуре, такой как Clore.ai.

Jan Server построен на [Cortex.cpp](https://github.com/janhq/cortex.cpp) движке вывода, высокопроизводительном рантайме, который поддерживает `llama.cpp`, `TensorRT-LLM`, и бэкенды ONNX. На Clore.ai вы можете арендовать GPU-сервер всего за **$0.20/hr**, запустить Jan Server с помощью Docker Compose, загрузить любую модель GGUF или GPTQ и обслуживать её через API, совместимый с OpenAI — и всё это без выхода ваших данных за пределы машины.

**Ключевые особенности:**

* 🔒 100% офлайн — данные никогда не покидают ваш сервер
* 🤖 API, совместимый с OpenAI (`/v1/chat/completions`, `/v1/models`, и т.д.)
* 📦 Хаб моделей с загрузкой моделей в одну команду
* 🚀 Ускорение на GPU через CUDA (бэкенды llama.cpp + TensorRT-LLM)
* 💬 Встроенное управление диалогами и история веток
* 🔌 Прямой заменитель OpenAI в существующих приложениях

***

## Требования

### Требования к аппаратному обеспечению

| Тариф                      | GPU           | VRAM  | ОЗУ    | Хранилище  | Clore.ai Цена |
| -------------------------- | ------------- | ----- | ------ | ---------- | ------------- |
| **Минимум**                | RTX 3060 12GB | 12 ГБ | 16 ГБ  | 50 ГБ SSD  | \~$0.10/час   |
| **Рекомендуется**          | RTX 3090      | 24 ГБ | 32 ГБ  | 100 ГБ SSD | ≈ $0.20/ч     |
| **Высокопроизводительный** | RTX 4090      | 24 ГБ | 64 ГБ  | 200 ГБ SSD | ≈ $0.35/ч     |
| **Большие модели**         | A100 80GB     | 80 ГБ | 128 ГБ | 500 ГБ SSD | ≈ $1.10/ч     |

### Справка по VRAM моделей

| Модель              | Требуемая VRAM | Рекомендуемый GPU |
| ------------------- | -------------- | ----------------- |
| Llama 3.1 8B (Q4)   | \~5 ГБ         | RTX 3060          |
| Llama 3.1 8B (FP16) | \~16 ГБ        | RTX 3090          |
| Llama 3.3 70B (Q4)  | ≈40 ГБ         | A100 40GB         |
| Llama 3.1 405B (Q4) | \~220 ГБ       | 4× A100 80GB      |
| Mistral 7B (Q4)     | \~4 ГБ         | RTX 3060          |
| Qwen2.5 72B (Q4)    | \~45 ГБ        | A100 80GB         |

### Программные предпосылки

* Аккаунт Clore.ai с пополненным кошельком
* Базовые знания Docker
* (Необязательно) OpenSSH клиент для проброса портов

***

## Быстрый старт

### Шаг 1 — Арендуйте сервер с GPU на Clore.ai

1. Перейдите по адресу [clore.ai](https://clore.ai) и выполните вход
2. Фильтровать серверы: **Тип GPU** → RTX 3090 или лучше, **Docker** → включено
3. Выберите сервер и выберите **Docker** вариант развертывания
4. Используйте официальный `nvidia/cuda:12.1.0-devel-ubuntu22.04` базовый образ или любой CUDA-образ
5. Открытые порты: **1337** (Jan Server API), **39281** (Cortex API), **22** (SSH)

### Шаг 2 — Подключитесь к вашему серверу

```bash
# Подключитесь по SSH к вашему Clore.ai серверу
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Проверить доступность GPU
nvidia-smi
```

### Шаг 3 — Установите Docker Compose (если отсутствует)

```bash
# Проверьте, доступен ли Docker Compose
docker compose version

# Установите, если отсутствует (Ubuntu/Debian)
apt-get update && apt-get install -y docker-compose-plugin

# Проверка
docker compose version
```

### Шаг 4 — Разверните Jan Server с помощью Docker Compose

```bash
# Создайте рабочую директорию
mkdir -p /workspace/jan-server && cd /workspace/jan-server

# Скачайте официальный docker-compose.yml Jan Server
curl -fsSL https://raw.githubusercontent.com/janhq/jan-server/main/docker-compose.yml \
  -o docker-compose.yml

# Просмотрите и отредактируйте конфигурацию
cat docker-compose.yml
```

Если upstream compose-файл недоступен или вы хотите полный контроль, создайте его вручную:

```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
# Запустите Jan Server
docker compose up -d

# Следите за логами запуска (ожидайте сообщение "Server started")
docker compose logs -f jan-server
```

### Шаг 5 — Проверьте, что сервер работает

```bash
# Проверьте здоровье сервера
curl http://localhost:1337/health

# Перечислите доступные модели (первоначально пусто)
curl http://localhost:1337/v1/models

# Ожидаемый ответ:
# {"object":"list","data":[]}
```

### Шаг 6 — Загрузите вашу первую модель

```bash
# Загрузите Llama 3.2 3B (хорошее начало, ~2GB)
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Или загрузите 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"}'

# Мониторьте прогресс загрузки
curl http://localhost:1337/v1/models
```

### Шаг 7 — Запустите модель и начните чат

```bash
# Запустите модель (загружает её в VRAM GPU)
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Отправьте ваш первый запрос в чат
curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Привет! Чем ты можешь мне помочь?"}
    ],
    "temperature": 0.7,
    "max_tokens": 512,
    "stream": false
  }'
```

***

## Конфигурация

### Переменные окружения

| Переменная             | По умолчанию          | Описание                                             |
| ---------------------- | --------------------- | ---------------------------------------------------- |
| `JAN_API_HOST`         | `0.0.0.0`             | Хост для привязки API сервера                        |
| `JAN_API_PORT`         | `1337`                | Порт API Jan Server                                  |
| `CORTEX_API_PORT`      | `39281`               | Внутренний порт движка Cortex                        |
| `CUDA_VISIBLE_DEVICES` | `all`                 | Какие GPU отображать (индексы, разделённые запятыми) |
| `JAN_DATA_FOLDER`      | `/root/jan`           | Путь к папке данных Jan                              |
| `CORTEX_MODELS_PATH`   | `/root/cortex/models` | Путь к хранилищу моделей                             |

### Конфигурация с несколькими GPU

Для серверов с несколькими GPU (например, 2× RTX 3090 на Clore.ai):

```yaml
environment:
  - CUDA_VISIBLE_DEVICES=0,1  # Использовать оба GPU
```

Или чтобы выделить конкретные GPU:

```bash
# Запустить Jan Server только на 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
```

### Пользовательская конфигурация модели

```bash
# Показать все загруженные модели
curl http://localhost:1337/v1/models | jq '.data[].id'

# Получить детали модели
curl http://localhost:1337/v1/models/llama3.2:3b-gguf-q4-km

# Остановить запущенную модель (освободить VRAM)
curl -X POST http://localhost:1337/v1/models/stop \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Удалить модель (освободить место на диске)
curl -X DELETE http://localhost:1337/v1/models/llama3.2:3b-gguf-q4-km
```

### Защита API с помощью токена

Jan Server по умолчанию не включает аутентификацию. Используйте Nginx как обратный прокси:

```bash
apt-get install -y nginx apache2-utils

# Создать файл паролей
htpasswd -c /etc/nginx/.htpasswd admin

# Настроить 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
```

***

## Ускорение с помощью GPU

### Проверка ускорения CUDA

Движок Cortex в Jan Server автоматически определяет CUDA. Проверьте, что используется GPU:

```bash
# Проверьте использование памяти GPU после загрузки модели
nvidia-smi

# Должно показывать процесс cortex, потребляющий VRAM
# Пример вывода:
# | Processes:                                                            |
# |  GPU   GI   CI        PID   Type   Process name            GPU Memory |
# |    0    N/A  N/A    12345    C   /usr/local/bin/cortex    8192MiB |
```

### Переключение бэкендов вывода

Cortex поддерживает несколько бэкендов:

```bash
# Проверьте, какие бэкенды доступны внутри контейнера
docker exec jan-server cortex engines list

# Используйте бэкенд TensorRT-LLM для NVIDIA GPU (быстрее, требует дополнительной настройки)
docker exec jan-server cortex engines install tensorrt-llm

# Используйте бэкенд llama.cpp (по умолчанию, наиболее совместимый)
docker exec jan-server cortex engines install llama-cpp
```

### Настройка окна контекста и размера батча

```bash
# Настройте параметры модели для производительности на 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
  }'
```

| Параметр     | Описание                                           | Рекомендация                                      |
| ------------ | -------------------------------------------------- | ------------------------------------------------- |
| `ngl`        | Слои на GPU (чем больше = тем больше загрузка GPU) | Установите в `99` чтобы максимально загрузить GPU |
| `ctx_len`    | Размер окна контекста                              | 4096–32768 в зависимости от VRAM                  |
| `n_batch`    | Размер батча для обработки подсказок               | 512 для RTX 3090, 256 для меньших                 |
| `n_parallel` | Параллельные слоты для запросов                    | 4–8 для использования в API сервере               |

***

## Подсказки и лучшие практики

### 🎯 Выбор моделей для бюджетов Clore.ai

```bash
# Уровень бюджета (~$0.10/hr, RTX 3060 12GB):
# Используйте кванты Q4_K_M для моделей 7B
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

# Стандартный уровень (~$0.20/hr, RTX 3090 24GB):
# Используйте кванты Q5_K_M для моделей 13B или Q4 для 30B
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.1:8b-instruct-gguf-q5-km"}'

# Высокий уровень (~$1.10/hr, A100 80GB):
# Запускайте полные 70B модели в высокой точности
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.3:70b-instruct-gguf-q4-km"}'
```

### 💾 Постоянное хранилище моделей

Поскольку инстансы Clore.ai эфемерны, рассмотрите возможность монтирования внешнего хранилища:

```bash
# Используйте именованный том (сохраняется с Docker)
docker compose down
# Модели сохраняются в именованном томе 'jan-models'

# Для по-настоящему постоянного хранения между инстансами,
# загрузите модели в объектное хранилище и подтягивайте при старте:
cat > /workspace/startup.sh << 'EOF'
#!/bin/bash
docker compose up -d
sleep 30
# Предзагрузите часто используемые модели
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
```

### 🔗 Использование Jan Server как замены OpenAI

```python
# Python — используйте существующие клиентские библиотеки OpenAI
from openai import OpenAI

client = OpenAI(
    base_url="http://<CLORE_IP>:1337/v1",
    api_key="not-required"  # Jan Server по умолчанию без аутентификации
)

response = client.chat.completions.create(
    model="llama3.2:3b-gguf-q4-km",
    messages=[{"role": "user", "content": "Объясни квантовые вычисления"}],
    temperature=0.7
)
print(response.choices[0].message.content)
```

```bash
# Поддержка стриминга
curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "messages": [{"role": "user", "content": "Напиши хайку о GPU"}],
    "stream": true
  }'
```

### 📊 Мониторинг использования ресурсов

```bash
# Наблюдайте за загрузкой GPU в реальном времени
watch -n 1 nvidia-smi

# Проверьте использование ресурсов контейнера
docker stats jan-server

# Просмотреть подробные логи
docker compose logs --tail=100 jan-server

# Проверить времена загрузки моделей
docker compose logs jan-server | grep -E "(loaded|started|error)"
```

***

## Устранение неполадок

### Контейнер не запускается — GPU не найден

```bash
# Убедитесь, что настроен NVIDIA Docker runtime
docker info | grep -i nvidia

# Проверьте доступ к GPU напрямую
docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi

# Если это не сработает, проверьте конфиг демона Docker
cat /etc/docker/daemon.json
# Должно содержать: {"runtimes": {"nvidia": {...}}}
```

### Загрузка модели зависла или не удалась

```bash
# Проверить свободное место на диске
df -h /root

# Проверьте логи контейнера на наличие ошибок
docker compose logs jan-server | tail -50

# Повторите попытку загрузки
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'
```

### Закончилась VRAM (CUDA out of memory)

```bash
# Проверьте текущее использование VRAM
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# Сначала остановите все запущенные модели
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

# Используйте более сильно квантизированную модель (Q3 или Q4 вместо Q8)
# Q4_K_M обычно использует ~50% требований VRAM от Q8
```

### Не удаётся подключиться к API из вне контейнера

```bash
# Убедитесь, что порт 1337 привязан ко всем интерфейсам
docker ps --format "table {{.Names}}\t{{.Ports}}"
# Должно показывать: 0.0.0.0:1337->1337/tcp

# Проверьте правила фаервола Clore.ai — откройте порт 1337 в настройках сервера
# Сначала протестируйте локально:
curl http://127.0.0.1:1337/health

# Затем протестируйте снаружи:
curl http://<CLORE_SERVER_IP>:<MAPPED_PORT>/health
```

### Медленный вывод (переход на CPU)

```bash
# Подтвердите, что используется CUDA (не CPU)
docker exec jan-server cortex ps
# Должно показывать выделенную память GPU

# Форсировать GPU-слои при запуске модели
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}'
```

***

## Дополнительное чтение

* [Официальная документация Jan.ai](https://jan.ai/docs) — Полная документация платформы
* [Репозиторий Jan на GitHub](https://github.com/janhq/jan) — Исходный код и issues
* [Jan Server / Jan API](https://github.com/janhq/jan-server) — Документы, специфичные для сервера
* [Движок Cortex.cpp](https://github.com/janhq/cortex.cpp) — Подлежащий движок вывода
* [Начало работы с Clore.ai](/guides/guides_v2-ru/nachalo-raboty/getting-started.md) — Основы платформы
* [Руководство по сравнению GPU](/guides/guides_v2-ru/nachalo-raboty/gpu-comparison.md) — Выберите подходящий GPU
* [Запуск Ollama на Clore.ai](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) — Альтернативный LLM сервер
* [Запуск vLLM на Clore.ai](/guides/guides_v2-ru/yazykovye-modeli/vllm.md) — Высокопроизводительный сервер вывода
* [Hugging Face Model Hub](https://huggingface.co/models?library=gguf) — Найдите модели GGUF

> 💡 **Совет по стоимости:** RTX 3090 на Clore.ai (\~$0.20/hr) может запускать Llama 3.1 8B с **\~50 токенов/сек** — достаточно для личного использования или API с низкой нагрузкой. Для производственных нагрузок рассмотрите vLLM (см. [руководство по vLLM](/guides/guides_v2-ru/yazykovye-modeli/vllm.md)) на A100.


---

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

```
GET https://docs.clore.ai/guides/guides_v2-ru/ai-platformy-i-agenty/jan.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.