> 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-ru/platformy-i-agenty-ii/jan.md).

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

Разверните сервер Jan.ai на Clore.ai — полностью офлайн LLM-сервер, совместимый с OpenAI, с хабом моделей, управлением беседами и инференсом на GPU на базе движка Cortex.

## Обзор

[Jan.ai](https://github.com/janhq/jan) — это open-source альтернатива 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/час**, запустить Jan Server с Docker Compose, загрузить любую модель GGUF или GPTQ и обслуживать её через API, совместимый с OpenAI, — и всё это без передачи ваших данных за пределы машины.

**Ключевые возможности:**

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

***

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

{% hint style="warning" %}
**Многопроцессорные конфигурации с GPU класса 80GB не представлены на маркетплейсе Clore.ai.** Самые крупные доступные сейчас машины — это 4× RTX PRO 6000 Blackwell (по 96GB, всего 380GB) и 8–11× RTX 5090 (по 32GB). Ёмкость A100 / H200 / B200 продаётся как [голое железо](https://clore.ai/bare-metal) по запросу. Проверьте [Цены и доступность GPU](/guides/guides_v2-ru/nachalo-raboty/pricing.md) перед выбором размера развёртывания.
{% endhint %}

### Требования к оборудованию

| Тариф              | GPU           | VRAM  | ОЗУ    | Хранилище  | Цена Clore.ai                               |
| ------------------ | ------------- | ----- | ------ | ---------- | ------------------------------------------- |
| **Минимум**        | RTX 3060 12GB | 12 ГБ | 16 ГБ  | 50 ГБ SSD  | $0.03–0.07/час                              |
| **Рекомендуется**  | RTX 3090      | 24 ГБ | 32 ГБ  | 100 ГБ SSD | $0.07–0.21/ч                                |
| **Высокий класс**  | RTX 4090      | 24 ГБ | 64 ГБ  | 200 ГБ SSD | $0.14–0.42/ч                                |
| **Большие модели** | A100 80 ГБ    | 80 ГБ | 128 ГБ | 500 ГБ SSD | [голое железо](https://clore.ai/bare-metal) |

### Справочник 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 40 ГБ        |
| Llama 3.1 405B (Q4) | \~220 ГБ       | 4× A100 80GB      |
| Mistral 7B (Q4)     | \~4 ГБ         | RTX 3060          |
| Qwen2.5 72B (Q4)    | \~45 ГБ        | A100 80 ГБ        |

### Необходимое ПО

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

***

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

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

1. Перейдите на [маркетплейсе clore.ai](https://clore.ai) и войдите в систему
2. Фильтруйте серверы: **Тип GPU** → RTX 3090 или лучше, **Docker** → включено
3. Выберите сервер и укажите **Docker** вариант развёртывания
4. Используйте официальный `nvidia/cuda:12.8.1-devel-ubuntu22.04` базовый образ или любой образ CUDA
5. Откройте порты: **1337** (API Jan Server), **39281** (API Cortex), **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 (хороший вариант для начала, ~2 ГБ)
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": "Вы — полезный помощник."},
      {"role": "user", "content": "Hello! What can you help me with?"}
    ],
    "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
# Пример вывода:
# | Процессы:                                                            |
# |  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 для GPU NVIDIA (быстрее, но требует большей настройки)
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.03–0.07/час, 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.07–0.21/час, 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"}'

# Высокий уровень ([bare metal](https://clore.ai/bare-metal), 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": "Explain quantum computing"}],
    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": "Write a haiku about GPUs"}],
    "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.8.1-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](https://huggingface.co/models?library=gguf) — найдите модели GGUF

> 💡 **Совет по стоимости:** RTX 3090 на Clore.ai ($0.07–0.21/час) может запускать Llama 3.1 8B на **\~50 токенов/секунду** — этого достаточно для личного использования или API с низкой нагрузкой. Для production-нагрузок рассмотрите vLLM (см. [руководство по vLLM](/guides/guides_v2-ru/yazykovye-modeli/vllm.md)) на 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-ru/platformy-i-agenty-ii/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.