# Локальная LLM GPT4All

## Обзор

[GPT4All](https://github.com/nomic-ai/gpt4all) от Nomic AI является одним из самых популярных проектов с открытым исходным кодом для локальных больших языковых моделей, с более чем **72 000 звёзд на GitHub**. Он позволяет запускать большие языковые модели полностью офлайн на вашем собственном оборудовании — не требуется подключение к интернету, данные не отправляются третьим сторонам.

GPT4All наиболее известен своим отполированным настольным приложением, но он также включает **библиотеку Python** (`gpt4all` пакет) и встроенный **совместимый с OpenAI сервер API** работающий на порту **4891**. На Clore.ai вы можете развернуть GPT4All в контейнере Docker на арендованном GPU, обслуживать его через HTTP и подключить любой клиент, совместимый с OpenAI.

> **Примечание по Docker:** GPT4All не публикует официальное Docker-изображение для серверного компонента. В этом руководстве используется пользовательская настройка Docker с `gpt4all` пакетом Python. Для более готовой к продакшену альтернативы в Docker, которая запускает **те же файлы модели GGUF**, смотрите [раздел про альтернативу LocalAI](#alternative-localai-docker-image) — LocalAI ориентирован на Docker и поддерживает идентичный формат моделей.

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

* 🔒 100% офлайн — всё выводится локально
* 🤖 REST API, совместимый с OpenAI (порт 4891)
* 📚 LocalDocs — RAG поверх ваших собственных документов
* 🧩 Поддерживает все популярные форматы моделей GGUF
* 🐍 Полный Python API с `pip install gpt4all`
* 💬 Прекрасный настольный интерфейс (не относится к серверу, но хорош для локального тестирования)

***

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

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

| Тариф                      | GPU           | VRAM  | ОЗУ   | Хранилище  | Clore.ai Цена               |
| -------------------------- | ------------- | ----- | ----- | ---------- | --------------------------- |
| **Только CPU**             | Нет           | —     | 16 ГБ | 50 ГБ SSD  | \~$0.02/час (сервер на CPU) |
| **Базовый GPU**            | 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/ч                   |

> **Примечание:** Поддержка GPU в GPT4All использует CUDA через llama.cpp. В отличие от vLLM, она **не** не требует конкретной вычислительной способности CUDA — RTX 10xx и новее обычно подходят.

### Требования к видеопамяти модели (GGUF Q4\_K\_M)

| Модель                | Размер на диске | VRAM    | Мин. GPU    |
| --------------------- | --------------- | ------- | ----------- |
| Phi-3 Mini 3.8B       | \~2,4 ГБ        | \~3 ГБ  | RTX 3060    |
| Mistral 7B Instruct   | \~4,1 ГБ        | \~5 ГБ  | RTX 3060    |
| Llama 3.1 8B Instruct | \~4,7 ГБ        | \~6 ГБ  | RTX 3060    |
| Llama 3 70B Instruct  | ≈40 ГБ          | \~45 ГБ | A100 80GB   |
| Mixtral 8x7B          | \~26 ГБ         | \~30 ГБ | 2× RTX 3090 |

***

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

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

1. Войдите в систему в [clore.ai](https://clore.ai)
2. Фильтр: **С поддержкой Docker**, **GPU**: RTX 3090 (для моделей 7B–13B)
3. Развернуть с образом: `nvidia/cuda:12.1.0-runtime-ubuntu22.04`
4. Открытые порты: **4891** (API GPT4All), **22** (SSH)
5. Выделите как минимум **50 ГБ** дискового пространства

### Шаг 2 — Подключитесь по SSH

```bash
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Проверить GPU
nvidia-smi
# Должен показать ваш GPU с версией драйвера
```

### Шаг 3 — Соберите Docker-образ GPT4All

Поскольку официального Docker-образа GPT4All нет, мы соберём его сами:

```bash
mkdir -p /workspace/gpt4all-server && cd /workspace/gpt4all-server

cat > Dockerfile << 'EOF'
FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Установить Python и системные зависимости
RUN apt-get update && apt-get install -y \
    python3.11 \
    python3.11-dev \
    python3-pip \
    curl \
    wget \
    git \
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# Сделать python3.11 по умолчанию
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \
    && update-alternatives --install /usr/bin/python python python3.11 1

# Установить GPT4All с поддержкой CUDA
RUN pip install --upgrade pip && \
    pip install gpt4all>=2.8.0 fastapi uvicorn aiofiles pydantic

# Создать директории
RUN mkdir -p /models /workspace /app

WORKDIR /app

# Скопировать серверный скрипт (будет примонтирован или включён внутрь образа)
COPY server.py .

EXPOSE 4891

CMD ["python", "server.py"]
EOF
```

### Шаг 4 — Создайте скрипт сервера API

```bash
cat > /workspace/gpt4all-server/server.py << 'PYEOF'
#!/usr/bin/env python3
"""
Совместимый с OpenAI сервер API GPT4All
Запускается на порту 4891 (по умолчанию GPT4All)
"""

import os
import time
import json
import asyncio
from typing import Optional, List, Dict, Any
from pathlib import Path

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import uvicorn
from gpt4all import GPT4All

# Конфигурация
MODEL_NAME = os.environ.get("MODEL_NAME", "Mistral 7B Instruct v0.1 Q4_0")
MODEL_PATH = os.environ.get("MODEL_PATH", "/models")
API_HOST = os.environ.get("API_HOST", "0.0.0.0")
API_PORT = int(os.environ.get("API_PORT", "4891"))
DEVICE = os.environ.get("DEVICE", "gpu")  # 'gpu', 'cpu', 'metal'
N_CTX = int(os.environ.get("N_CTX", "4096"))

app = FastAPI(title="GPT4All API Server", version="1.0.0")

# Глобальный экземпляр модели
model = None

def load_model():
    global model
    print(f"Загрузка модели: {MODEL_NAME}")
    print(f"Путь к модели: {MODEL_PATH}")
    print(f"Устройство: {DEVICE}")
    model = GPT4All(
        model_name=MODEL_NAME,
        model_path=MODEL_PATH,
        device=DEVICE,
        n_ctx=N_CTX,
        allow_download=True,  # Загружает с хаба GPT4All, если отсутствует
        verbose=True
    )
    print("Модель успешно загружена!")

# --- Pydantic модели ---

class Message(BaseModel):
    role: str
    content: str

class ChatCompletionRequest(BaseModel):
    model: str
    messages: List[Message]
    temperature: float = 0.7
    max_tokens: int = 512
    top_p: float = 0.95
    top_k: int = 40
    stream: bool = False

class CompletionRequest(BaseModel):
    model: str
    prompt: str
    temperature: float = 0.7
    max_tokens: int = 512
    stream: bool = False

# --- Маршруты API ---

@app.get("/health")
async def health():
    return {"status": "ok", "model": MODEL_NAME, "device": DEVICE}

@app.get("/v1/models")
async def list_models():
    return {
        "object": "list",
        "data": [{
            "id": MODEL_NAME,
            "object": "model",
            "created": int(time.time()),
            "owned_by": "gpt4all",
        }]
    }

@app.post("/v1/chat/completions")
async def chat_completions(request: ChatCompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Model not loaded")

    # Форматируем сообщения в один промпт
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### System:\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### Human:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Assistant:\n{msg.content}")
    prompt_parts.append("### Assistant:")
    full_prompt = "\n\n".join(prompt_parts)

    with model.chat_session():
        response_text = model.generate(
            full_prompt,
            max_tokens=request.max_tokens,
            temp=request.temperature,
            top_p=request.top_p,
            top_k=request.top_k,
        )

    return {
        "id": f"chatcmpl-{int(time.time())}",
        "object": "chat.completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "index": 0,
            "message": {"role": "assistant", "content": response_text},
            "finish_reason": "stop"
        }],
        "usage": {
            "prompt_tokens": len(full_prompt.split()),
            "completion_tokens": len(response_text.split()),
            "total_tokens": len(full_prompt.split()) + len(response_text.split())
        }
    }

@app.post("/v1/completions")
async def completions(request: CompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Model not loaded")

    response_text = model.generate(
        request.prompt,
        max_tokens=request.max_tokens,
        temp=request.temperature,
    )

    return {
        "id": f"cmpl-{int(time.time())}",
        "object": "text_completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "text": response_text,
            "index": 0,
            "finish_reason": "stop"
        }]
    }

if __name__ == "__main__":
    load_model()
    uvicorn.run(app, host=API_HOST, port=API_PORT, log_level="info")
PYEOF
```

### Шаг 5 — Сборка и запуск

```bash
cd /workspace/gpt4all-server

# Собрать Docker-образ
docker build -t gpt4all-server:latest .

# Сначала скачайте модель (опционально — сервер может автоматически загрузить)
mkdir -p /workspace/models
wget -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \
  https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf

# Запуск с поддержкой GPU
docker run -d \
  --name gpt4all-server \
  --gpus all \
  --restart unless-stopped \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -v /workspace/gpt4all-server/server.py:/app/server.py \
  -e MODEL_NAME="mistral-7b-instruct-v0.1.Q4_0.gguf" \
  -e MODEL_PATH="/models" \
  -e DEVICE="gpu" \
  -e N_CTX="4096" \
  gpt4all-server:latest

# Отслеживать логи
docker logs -f gpt4all-server
```

### Шаг 6 — Тестирование API

```bash
# Проверка здоровья
curl http://localhost:4891/health

# Список моделей
curl http://localhost:4891/v1/models

# Chat completion
curl http://localhost:4891/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-7b-instruct-v0.1.Q4_0.gguf",
    "messages": [
      {"role": "user", "content": "Какова столица Франции?"}
    ],
    "temperature": 0.7,
    "max_tokens": 256
  }'
```

***

## Альтернатива: Docker-образ LocalAI

Для более надёжного, готового к продакшену развёртывания в Docker, которое запускает **те же модели GGUF** как GPT4All, рекомендуется LocalAI. У него есть официальное Docker-изображение, поддержка CUDA и он активно поддерживается:

```bash
# Загрузить LocalAI с поддержкой CUDA
docker pull localai/localai:latest-aio-gpu-nvidia-cuda-12

# Создать директорию для моделей и скачать GGUF модель
mkdir -p /workspace/localai-models
wget -O /workspace/localai-models/mistral-7b.gguf \
  https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf

# Создать конфигурацию модели
cat > /workspace/localai-models/mistral-7b.yaml << 'EOF'
name: mistral-7b
parameters:
  model: mistral-7b.gguf
  temperature: 0.7
  top_p: 0.95
  top_k: 40
  max_tokens: 2048
context_size: 4096
f16: true
gpu_layers: 35
threads: 8
EOF

# Запустить LocalAI
docker run -d \
  --name localai \
  --gpus all \
  --restart unless-stopped \
  -p 8080:8080 \
  -v /workspace/localai-models:/build/models \
  -e DEBUG=true \
  localai/localai:latest-aio-gpu-nvidia-cuda-12

# Тест LocalAI (тот же API, совместимый с OpenAI)
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

***

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

### Переменные окружения для GPT4All сервера

| Переменная   | По умолчанию             | Описание                                |
| ------------ | ------------------------ | --------------------------------------- |
| `MODEL_NAME` | `mistral-7b-instruct...` | Имя файла модели или имя в хабе GPT4All |
| `MODEL_PATH` | `/models`                | Директория, содержащая файлы моделей    |
| `DEVICE`     | `gpu`                    | `gpu`, `cpu`, или `metal` (macOS)       |
| `N_CTX`      | `4096`                   | Размер окна контекста (токены)          |
| `API_HOST`   | `0.0.0.0`                | Адрес привязки                          |
| `API_PORT`   | `4891`                   | Порт для сервера API                    |

### Настройка Docker Compose

```yaml
# /workspace/gpt4all-server/docker-compose.yml
version: '3.8'

services:
  gpt4all-server:
    build: .
    container_name: gpt4all-server
    restart: unless-stopped
    ports:
      - "4891:4891"
    volumes:
      - /workspace/models:/models
      - ./server.py:/app/server.py
    environment:
      - MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf
      - MODEL_PATH=/models
      - DEVICE=gpu
      - N_CTX=4096
      - API_PORT=4891
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:4891/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 120s
```

```bash
docker compose up -d
docker compose logs -f
```

***

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

### Проверка использования GPU

Библиотека GPT4All для Python использует `llama.cpp` под капотом с поддержкой CUDA:

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

# Проверить внутри контейнера, что CUDA доступна
docker exec gpt4all-server python3 -c "
from gpt4all import GPT4All
devices = GPT4All.list_gpus()
print('Доступные GPU:', devices)
"
```

### Выбор слоёв для GPU

Параметр `gpu_layers` (или `n_gpu_layers`) контролирует, какая часть модели будет работать на GPU или CPU:

```python
# В server.py — заставить все слои работать на GPU
model = GPT4All(
    model_name=MODEL_NAME,
    model_path=MODEL_PATH,
    device="gpu",
    n_ctx=N_CTX,
    # Дополнительные параметры llama.cpp, передаваемые далее:
    # n_gpu_layers=99  # Все слои на GPU
)
```

```bash
# Пересобрать и перезапустить с максимальным количеством слоёв на GPU
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d \
  --name gpt4all-server \
  --gpus all \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=gpu \
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \
  gpt4all-server:latest
```

### Режим отката на CPU

Если GPU недоступен (например, сервер Clore.ai только с CPU для тестирования):

```bash
docker run -d \
  --name gpt4all-server-cpu \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest
```

> ⚠️ Вывод на CPU **в 10–50× медленнее** чем на GPU. Для серверов только на CPU используйте небольшие модели (Phi-3 Mini, TinyLlama) и ожидайте 2–5 токенов/сек.

***

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

### 📥 Предзагрузка моделей

Вместо полагания на автоматическую загрузку при запуске, предзагружайте модели для более быстрого перезапуска:

```bash
# Скачать популярные модели GPT4All
mkdir -p /workspace/models

# Mistral 7B (самая популярная, хорошее качество)
wget -q -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf"

# Phi-3 Mini (самая быстрая, самая маленькая)
wget -q -O /workspace/models/Phi-3-mini-4k-instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Phi-3-mini-4k-instruct.Q4_0.gguf"

# Llama 3 (лучшее качество в диапазоне 8B)
wget -q -O /workspace/models/Meta-Llama-3-8B-Instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Meta-Llama-3-8B-Instruct.Q4_0.gguf"

ls -lh /workspace/models/
```

### 🔌 Использование с Python-приложениями

```python
# Прямое использование в Python (без Docker API)
from gpt4all import GPT4All

model = GPT4All(
    model_name="mistral-7b-instruct-v0.1.Q4_0.gguf",
    model_path="/workspace/models",
    device="gpu"
)

# Простая генерация
with model.chat_session():
    response = model.generate("Объясните вычисления на GPU простыми словами", max_tokens=200)
    print(response)

# Использование серверного API с клиентом OpenAI
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:4891/v1",
    api_key="не_требуется"
)

completion = client.chat.completions.create(
    model="mistral-7b-instruct-v0.1.Q4_0.gguf",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(completion.choices[0].message.content)
```

### 💰 Оптимизация затрат на Clore.ai

```bash
# RTX 3090 @ $0.20/час — используйте для моделей 7B (лучшее соотношение цена/качество)
# Ожидаемая пропускная способность: ~40 токенов/сек для Mistral 7B Q4
# Стоимость на 1M сгенерированных токенов: ~$0.005 (очень дешево по сравнению с OpenAI)

# RTX 4090 @ $0.35/час — используйте для моделей 13B или когда важна скорость
# Ожидаемая пропускная способность: ~60 токенов/сек для Mistral 7B Q4

# Для пакетной обработки: загрузите модель заранее, обработайте все промпты, затем выключите
docker run --rm \
  --gpus all \
  -v /workspace/models:/models \
  -v /workspace/prompts:/prompts \
  gpt4all-server:latest \
  python3 -c "
from gpt4all import GPT4All
import json

model = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/models', device='gpu')
prompts = open('/prompts/batch.txt').readlines()
results = []
for p in prompts:
    with model.chat_session():
        results.append(model.generate(p.strip(), max_tokens=256))
json.dump(results, open('/prompts/results.json', 'w'))
print(f'Обработано {len(results)} промптов')
"
```

***

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

### Модель не загружается — файл не найден

```bash
# Проверьте, что файл модели существует и имеет правильное имя
ls -lh /workspace/models/
docker exec gpt4all-server ls /models/

# GPT4All чувствителен к регистру в именах моделей
# Используйте точное имя файла из вывода ls как MODEL_NAME
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \
  gpt4all-server:latest
```

### Ошибка CUDA: нет образа ядра для этой архитектуры

```bash
# Возможно, ваш GPU несовместим с версией CUDA
# Проверьте вычислительную способность GPU
nvidia-smi --query-gpu=compute_cap --format=csv,noheader

# Если < 6.0, используйте режим CPU
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest
```

### API возвращает 503 — модель не загружена

```bash
# Проверьте логи при старте
docker logs gpt4all-server | head -50

# Загрузка модели может занять 30–120 секунд
# Подождите и попробуйте снова:
sleep 60 && curl http://localhost:4891/health

# Проверьте, не повреждён ли файл модели
python3 -c "
from gpt4all import GPT4All
m = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/workspace/models')
print('Модель в порядке:', m)
"
```

### Порт 4891 недоступен извне

```bash
# Проверьте привязку порта
docker ps | grep 4891
# Должно показать: 0.0.0.0:4891->4891/tcp

# Проверьте, нет ли правил файрвола у Clore.ai
# В настройках сервера Clore.ai убедитесь, что порт 4891 указан как открытый

# Тест изнутри:
curl http://127.0.0.1:4891/health

# Примечание: Clore.ai отображает порты случайным образом — используйте порт, показанный в панели вашего сервера
```

***

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

* [GPT4All на GitHub](https://github.com/nomic-ai/gpt4all) — Основной репозиторий
* [GPT4All Python Docs](https://docs.gpt4all.io/) — Справочник по Python API
* [GPT4All Model Explorer](https://gpt4all.io/models/gguf/) — Просматривать доступные модели
* [Документация LocalAI](https://localai.io/) — Альтернатива, дружелюбная к Docker
* [Ollama на Clore.ai](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/ollama) — Проще разворачивать LLM в Docker
* [vLLM на Clore.ai](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/vllm) — Сервер для инференса в продакшене
* [Руководство по сравнению GPU](https://docs.clore.ai/guides/guides_v2-ru/nachalo-raboty/gpu-comparison) — Выберите подходящий GPU на Clore.ai
* [TheBloke на HuggingFace](https://huggingface.co/TheBloke) — Тысячи квантований GGUF
* [Объяснение формата GGUF](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) — Документация по формату модели

> 💡 **Рекомендация:** Если вы хотите самое простое развёртывание в Docker для локальных LLM, рассмотрите [Ollama](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/ollama) вместо этого — у него есть официальное Docker-изображение, встроенная поддержка GPU и он специально разработан для серверного развёртывания. Сильные стороны GPT4All — его прекрасный настольный интерфейс и функции LocalDocs (RAG), которые недоступны в серверном режиме.