🐋 DeepSeek локально — полный гайд и курс на русском (2026)

Как установить, запустить и настроить DeepSeek V4, R1 и дистилляты на своём ПК, Mac и сервере — бесплатно, приватно и без интернета.

Быстрый старт · Выбор модели · Ollama · llama.cpp · API · Фишки · FAQ

⭐ Поставь звезду — так гайд найдут другие.

TL;DR. DeepSeek — семейство открытых языковых моделей (open-weight, лицензия MIT) от китайской лаборатории DeepSeek-AI. На обычном компьютере проще всего запустить дистилляты DeepSeek-R1 (1.5B–70B) одной командой ollama run deepseek-r1:8b. Самая новая модель — DeepSeek-V4.1-Flash-1017 (17.10.2026, ~552B + Engram, 8–16B активных, текст и картинки, контекст 1M). Её запускают на серверах через SGLang/vLLM. Для дома лучший флагман — V4-Flash-0731 (284B / 13B активных): с llama.cpp она влезает в ~110 ГБ. Ниже полный пошаговый гайд: от первой команды до своего сервера с API, веб-поиском, RAG и агентами. 🧠 Machinelearning — разбор послжених моделей и их сравнение Экспертно в картинках, кладезь знаний для разработчков в 2026 году! А здесь выложены гайды по работе с откырытми моделями и уроки по работе с ними.

🆕 Новое в октябре 2026: вышла DeepSeek-V4.1-Flash-1017 (DeepSWE 77.0, быстрее и короче ответы), а у DeepSeek появились официальные Search и Fetch API для агентов. Подробно о всех моделях и железе под них — в части 3 и уроке 15.

0. 📡 Топ ресурсы, чтобы следить за ИИ
1. Быстрый старт за 5 минут
2. Что такое DeepSeek и зачем запускать локально
3. Какую модель DeepSeek выбрать
4. Железо: сколько нужно памяти
5. Ollama — установка и настройка
6. llama.cpp и запуск DeepSeek V4-Flash
7. LM Studio, Open WebUI и другие интерфейсы
8. vLLM и SGLang — сервер для команды
9. API, Python и подключение к IDE
10. Промптинг DeepSeek: как получать лучшие ответы
11. Ускорение и оптимизация
12. RAG и агенты
13. Дообучение (fine-tuning) под свои задачи
14. Топ-30 фишек и приёмов
15. Ошибки и их решение
16. FAQ
17. Глоссарий
18. Подробные уроки, примеры и конфиги

flowchart LR
    A["👋 Новичок"] --> B["Часть 1<br/>Быстрый старт"]
    B --> C["Часть 3<br/>Выбор модели"]
    C --> D{"Что дальше?"}
    D -->|"Хочу чат как ChatGPT"| E["Часть 7<br/>Open WebUI / LM Studio"]
    D -->|"Пишу код"| F["Часть 9<br/>API и IDE"]
    D -->|"Огромная модель"| G["Часть 6<br/>llama.cpp + V4-Flash"]
    D -->|"Сервер для команды"| H["Часть 8<br/>vLLM / SGLang"]
    F --> I["Часть 12<br/>RAG и агенты"]
    G --> J["Часть 11<br/>Ускорение"]
    H --> J

Проверь установку:

ollama --version

ollama run deepseek-r1:8b

Первый запуск скачает модель (~5 ГБ). Потом можно писать вопросы прямо в терминале. Выход — /bye.

💡 Не знаешь, какой размер выбрать? Видеопамять 4–6 ГБ → 1.5b/7b, 8 ГБ → 8b, 12–16 ГБ → 14b, 24 ГБ → 32b. Подробнее — в части 3.

Нужен Docker Desktop:

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

Открой http://localhost:3000, создай аккаунт администратора (он локальный) и выбери модель deepseek-r1:8b.

Не хочешь терминал и Docker? Поставь LM Studio: найди deepseek в поиске, скачай модель и общайся в окне программы.

flowchart TD
    S(["Хочу DeepSeek у себя"]) --> Q{"Нравится терминал?"}
    Q -->|"Нет"| LM["LM Studio<br/>скачать → поиск deepseek → Download → Chat"]
    Q -->|"Да"| OL["Ollama<br/>ollama run deepseek-r1:8b"]
    OL --> UI{"Нужен веб-интерфейс?"}
    UI -->|"Да"| OW["Open WebUI в Docker<br/>http://localhost:3000"]
    UI -->|"Нет"| T["Чат в терминале / API :11434"]
    LM --> API2["API :1234"]

DeepSeek — ИИ-лаборатория из Ханчжоу (Китай). Она публикует большие языковые модели с открытыми весами: их можно скачать и запускать где угодно, в том числе в коммерческих проектах (лицензия MIT).

timeline
    title Эволюция моделей DeepSeek
    2024 : V2 — MoE и MLA
         : V3 — 671B, FP8
    2025 : R1 — reasoning через RL
         : Дистилляты R1 1.5B–70B
         : V3.1 / V3.2 — гибрид think / no-think
    Апрель 2026 : V4-Flash 284B и V4-Pro 1.6T — контекст 1M
    Июль–август 2026 : V4-Flash-0731 и V4-Pro-0813
    Сентябрь 2026 : V4.1-Flash — encoder-decoder, картинки
    Октябрь 2026 : V4.1-Flash-1017 и Search / Fetch API

Как работает MoE (смесь экспертов):

flowchart LR
    T["Токен"] --> R{"Роутер"}
    R -->|"выбран"| E1["Эксперт 7"]
    R -->|"выбран"| E2["Эксперт 42"]
    R -.->|"спит"| E3["Эксперт 1…256"]
    SH["Общий эксперт"] --> O
    T --> SH
    E1 --> O["Выход слоя"]
    E2 --> O

Вся модель хранится в памяти, но считается только малая часть. Поэтому MoE нужно много памяти, но мало вычислений.

• MoE (Mixture of Experts, смесь экспертов). Модель состоит из множества «экспертов», но на каждый токен работает лишь малая часть. V4-Flash весит 284B, а считает как ~13B. Поэтому памяти нужно много, а вычислений мало, и для MoE хорошо подходит связка «много RAM + одна видеокарта».
• Режим размышлений (thinking). Сначала модель пишет рассуждение (<think>…</think>), потом ответ. Так она лучше решает математику, код и логику, но ответ получается медленнее и тратит больше токенов.
• Дистиллят. Маленькая модель (Qwen или Llama), дообученная на ответах большой R1. Все deepseek-r1:1.5b…70b в Ollama — дистилляты.
• Квантизация. Сжатие весов с 16 до 8/4/3/2 бит. Q4 примерно в 4 раза меньше FP16 и почти не теряет в качестве.
• GGUF. Формат файлов модели для llama.cpp, Ollama и LM Studio. Квант виден в названии файла: Q4_K_M, Q8_0, IQ3_XXS.

Минусы: нужно хорошее железо, маленькие модели слабее облачных флагманов, настройка требует времени.

* Только веса. Под контекст нужно добавить память на KV-кэш (см. часть 4). ** Если модель целиком помещается в видеопамять.

flowchart TD
    A(["Какое у тебя железо?"]) --> B{"Тип"}
    B -->|"Только CPU"| C["deepseek-r1:1.5b – 8b<br/>3–10 ток/с"]
    B -->|"NVIDIA / AMD"| D{"Видеопамять"}
    B -->|"Mac Apple Silicon"| M{"Объём памяти"}
    B -->|"Сервер 8× GPU"| SRV["V4.1-Flash-1017 FP8<br/>или V4-Pro-0813"]
    B -->|"Ничего нет"| CL["Облако: API DeepSeek,<br/>Ollama Cloud"]
    D -->|"4–8 ГБ"| D1["deepseek-r1:8b"]
    D -->|"12–16 ГБ"| D2["deepseek-r1:14b"]
    D -->|"24–32 ГБ"| D3["deepseek-r1:32b"]
    D -->|"48+ ГБ"| D4["deepseek-r1:70b"]
    D -->|"24 ГБ + 128 ГБ RAM"| D5["V4-Flash-0731<br/>эксперты в RAM"]
    M -->|"16 ГБ"| M1["8b"]
    M -->|"32 ГБ"| M2["14b – 32b"]
    M -->|"64 ГБ"| M3["70b"]
    M -->|"128–192 ГБ"| M4["V4-Flash-0731"]
    M -->|"256–512 ГБ"| M5["V4.1-Flash MLX"]

✅ — влезает целиком на GPU · ⚠️ — с частичным оффлоадом в RAM (медленнее) · ❌ — не запустится разумно

📖 Полный каталог всех версий и разновидностей с железом под каждую: docs/15-modeli-i-zhelezo.md

⚠️ Важно: дистилляты R1 — это Qwen/Llama, обученные «думать как R1». Они хороши в математике и коде, но знаний и русского языка у них меньше, чем у полноразмерного DeepSeek. Для русского лучше брать 14B и выше.

Память ≈ Параметры × (бит на вес / 8) + KV-кэш + 1–2 ГБ

pie showData
    title Память, ГБ (≈ 14 ГБ всего)
    "Веса модели" : 9
    "KV-кэш 32K (FP16)" : 3.5
    "Буферы и накладные" : 1.5

Включи OLLAMA_KV_CACHE_TYPE=q8_0, и KV-кэш станет вдвое меньше: ~1.75 ГБ вместо 3.5.

💡 Правило: большая модель в низком кванте почти всегда лучше маленькой в высоком. 32B-Q4 > 14B-Q8. Но ниже 3 бит качество падает резко.

• NVIDIA (CUDA). Лучшая поддержка: работает всё.
• AMD. Ollama и llama.cpp работают через ROCm (поддерживаемые карты) или Vulkan (почти все). vLLM работает на Instinct с ROCm.
• Apple Silicon. Благодаря единой памяти это самый дешёвый способ запустить огромную модель. Генерация быстрая, а длинный промпт обрабатывается медленнее, чем на NVIDIA.
• Intel Arc. Через Vulkan или SYCL в llama.cpp.

ollama pull deepseek-r1:14b       # скачать модель
ollama run deepseek-r1:14b        # чат в терминале
ollama run deepseek-r1:14b --verbose   # + скорость в токенах/с
ollama list                       # установленные модели
ollama ps                         # что в памяти и на GPU или CPU
ollama stop deepseek-r1:14b       # выгрузить из памяти
ollama rm deepseek-r1:14b         # удалить
ollama show deepseek-r1:14b       # параметры, шаблон, лицензия

V4.1-Flash локально в Ollama пока не запускается (архитектура deepseek_v41 не поддерживается движком), доступна только облачно: deepseek-v4.1-flash.

• deepseek-r1:1.5b, 7b, 8b, 14b, 32b, 70b — дистилляты, работают локально
• deepseek-r1:671b — полная R1 (нужно 400+ ГБ)
• deepseek-v3, deepseek-v3.1, deepseek-coder-v2 — прошлые поколения
• deepseek-v4-flash:cloud, deepseek-v4-pro:cloud — облачные теги: модель работает на серверах ollama.com, веса не скачиваются (сначала ollama signin)

/set parameter num_ctx 16384      # размер контекста
/set parameter temperature 0.6    # температура
/set system "Отвечай только на русском языке."
/set think                        # включить размышления
/set nothink                      # выключить размышления
/save ds-ru                       # сохранить как новую модель
/bye                              # выход

Создай файл Modelfile:

FROM deepseek-r1:14b

PARAMETER num_ctx 16384
PARAMETER temperature 0.6
PARAMETER top_p 0.95
PARAMETER repeat_penalty 1.05
PARAMETER num_predict 4096

SYSTEM """Ты — полезный ассистент. Всегда отвечай на русском языке, кратко и по делу."""

ollama create ds-ru -f Modelfile
ollama run ds-ru

ollama run hf.co/unsloth/DeepSeek-R1-0528-Qwen3-8B-GGUF:Q4_K_M

Или из локального файла: в Modelfile пишешь FROM ./model-Q4_K_M.gguf.

Как задать переменные:

• Windows: Пуск → «Изменение системных переменных среды» → «Переменные среды» → «Создать». Потом перезапусти Ollama (иконка в трее → Quit → запусти снова).
• macOS: launchctl setenv OLLAMA_FLASH_ATTENTION 1, затем перезапусти приложение Ollama.
• Linux: sudo systemctl edit ollama и добавь:

  [Service]
  Environment="OLLAMA_FLASH_ATTENTION=1"
  Environment="OLLAMA_KV_CACHE_TYPE=q8_0"
  Environment="OLLAMA_CONTEXT_LENGTH=32768"
  Environment="OLLAMA_KEEP_ALIVE=-1"

  потом sudo systemctl daemon-reload && sudo systemctl restart ollama.

ollama ps

В колонке PROCESSOR должно быть 100% GPU. Если видишь 30%/70% CPU/GPU, часть модели ушла в оперативную память и скорость упадёт в разы. Уменьши контекст или возьми модель меньше.

📖 Подробнее: docs/03-ollama.md

flowchart LR
    subgraph Клиенты
        CLI["ollama run"]
        WEB["Open WebUI"]
        IDE["VS Code / Continue"]
        PY["Python / JS"]
    end
    CLI --> API["Ollama API<br/>:11434"]
    WEB --> API
    IDE --> API
    PY --> API
    API --> ENG["Движок<br/>на базе llama.cpp"]
    ENG --> GPU["GPU<br/>CUDA / ROCm / Metal"]
    ENG -.->|"если не влезло"| CPU["CPU + RAM"]
    LIB[("~/.ollama/models<br/>GGUF-файлы")] --> ENG

llama.cpp — движок, на котором построены Ollama и LM Studio. Он первым получает поддержку новых моделей и даёт полный контроль над тем, что лежит на GPU, а что в RAM.

Готовые сборки: GitHub Releases (Windows, macOS, Linux), на Mac — brew install llama.cpp.

Сборка из исходников:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON      # NVIDIA
# cmake -B build                   # Mac (Metal включён сам)
# cmake -B build -DGGML_VULKAN=ON  # AMD / Intel / любая GPU
cmake --build build --config Release -j

llama-cli -hf unsloth/DeepSeek-R1-0528-Qwen3-8B-GGUF:Q4_K_M \
  -ngl 99 -c 16384 --temp 0.6 --top-p 0.95

1. Скачай квант (~103 ГБ для 3-бит):

pip install -U huggingface_hub
hf download unsloth/DeepSeek-V4-Flash-0731-GGUF \
  --local-dir models/V4-Flash --include "*UD-IQ3_XXS*"

2а. Mac Studio / DGX Spark (вся модель в единой памяти):

llama-server \
  -m models/V4-Flash/UD-IQ3_XXS/DeepSeek-V4-Flash-0731-UD-IQ3_XXS-00001-of-00004.gguf \
  -ngl 99 -c 32768 --temp 1.0 --top-p 1.0 --min-p 0.01 --jinja

2б. Обычный ПК: одна GPU 24 ГБ + 128 ГБ RAM 🔥

llama-server \
  -m models/V4-Flash/UD-IQ3_XXS/DeepSeek-V4-Flash-0731-UD-IQ3_XXS-00001-of-00004.gguf \
  -ngl 99 -ot ".ffn_.*_exps.=CPU" \
  -c 32768 -t 16 -fa on \
  --cache-type-k q8_0 --cache-type-v q8_0 \
  --temp 1.0 --top-p 1.0 --min-p 0.01 --jinja

Как это работает. -ngl 99 отправляет все слои на GPU, а -ot (override-tensor) возвращает тяжёлых «экспертов» MoE в оперативную память. На видеокарте остаются внимание и общие слои, то есть то, что считается на каждом токене. Так модель на 284B работает с одной игровой картой.

flowchart LR
    subgraph GPU["🎮 Видеокарта 24 ГБ"]
        A1["Внимание (attention)"]
        A2["Общие эксперты"]
        A3["Эмбеддинги и KV-кэш"]
    end
    subgraph RAM["🧠 Оперативная память 128 ГБ"]
        B1["Маршрутизируемые эксперты<br/>~90% весов"]
    end
    A1 <-->|"каждый токен"| B1

Указывай первый файл из частей (-00001-of-0000N), остальные подхватятся сами. Названия чекпойнтов меняются, поэтому актуальные смотри на странице Unsloth.

--reasoning off                                      # отвечать сразу
--chat-template-kwargs '{"enable_thinking":false}'  # то же через шаблон
--chat-template-kwargs '{"reasoning_effort":"max"}' # максимум размышлений

llama-cli -m <V4-Flash-00001-of-0000N.gguf> \
  -md dspark-DeepSeek-V4-Flash-0731-Q8_0.gguf \
  --spec-type draft-dspark --spec-draft-n-max 3 \
  -ngl 99 -ngld 99 --temp 1.0 --top-p 1.0 --min-p 0.01

Маленький драфтер угадывает несколько токенов вперёд, а большая модель их проверяет. По данным Unsloth это ускоряет генерацию в 1.5–2 раза и требует ~10 ГБ дополнительной памяти.

llama-server сразу даёт веб-чат на http://localhost:8080 и OpenAI-совместимый API на http://localhost:8080/v1.

📖 Подробнее: docs/04-llama-cpp.md

1. Скачай с lmstudio.ai (Windows, macOS, Linux).
2. Открой поиск 🔍, введи deepseek, выбери модель и квант. Зелёная метка означает, что модель поместится в твою видеокарту.
3. Чатись во вкладке Chat, а во вкладке Developer → Start Server включается API на http://localhost:1234/v1.

Фишки: на Mac есть движок MLX (часто быстрее GGUF), ползунок «сколько слоёв на GPU» и CLI lms для скриптов.

Возможности: история чатов, загрузка документов (RAG), веб-поиск, голосовой ввод, несколько пользователей с ролями.

Всё в одном (Ollama + Open WebUI) через docker compose:

services:
  ollama:
    image: ollama/ollama:latest
    volumes: [ollama:/root/.ollama]
    environment:
      - OLLAMA_FLASH_ATTENTION=1
      - OLLAMA_KV_CACHE_TYPE=q8_0
      - OLLAMA_CONTEXT_LENGTH=16384
    deploy:
      resources:
        reservations:
          devices: [{driver: nvidia, count: all, capabilities: [gpu]}]
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports: ["127.0.0.1:3000:8080"]
    environment: [OLLAMA_BASE_URL=http://ollama:11434]
    volumes: [open-webui:/app/backend/data]
volumes: {ollama: {}, open-webui: {}}

docker compose up -d
docker compose exec ollama ollama pull deepseek-r1:14b

Готовый файл: configs/docker-compose.yml.

Подключить llama.cpp или vLLM вместо Ollama: Admin Panel → Settings → Connections → OpenAI API → URL http://host.docker.internal:8080/v1.

Фишки Open WebUI:

• рассуждения модели сворачиваются в блок «Думал N секунд»;
• # в поле ввода прикрепляет документ или ссылку;
• Workspace → Models: своя «персона» поверх DeepSeek с системным промптом;
• Workspace → Knowledge: база документов для всех чатов;
• Arena: слепое сравнение двух моделей.

📖 Подробнее: docs/06-interfeisy.md

Ollama и llama.cpp рассчитаны на одного пользователя. Если запросы идут от 5+ человек одновременно, нужны движки с continuous batching: vLLM или SGLang. Их суммарная пропускная способность в разы выше.

flowchart LR
    U1["👤 Пользователь 1"] --> P
    U2["👤 Пользователь 2"] --> P
    U3["👤 …N"] --> P
    P["nginx / Caddy<br/>HTTPS + авторизация"] --> OW["Open WebUI"]
    P --> APIK["Свои сервисы<br/>по API-ключу"]
    OW --> V["vLLM / SGLang<br/>continuous batching"]
    APIK --> V
    V --> G1["GPU 0"]
    V --> G2["GPU 1"]
    V --> G3["… GPU 7"]

pip install -U vllm

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
  --tensor-parallel-size 2 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.92 \
  --reasoning-parser deepseek_r1 \
  --api-key change-me

--reasoning-parser выносит рассуждения в поле reasoning_content, так что в content остаётся только ответ.

pip install -U "sglang[all]"
python3 -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Flash --tp 8 --trust-remote-code \
  --host 0.0.0.0 --port 30000

⚠️ Поддержка V4 зависит от версии движка и поколения GPU (Hopper/Blackwell). Сверяйся с карточкой модели и рецептами vLLM.

📖 Подробнее: docs/05-vllm-sglang.md

Все движки отдают OpenAI-совместимый API, поэтому код один и тот же, меняется только адрес:

from openai import OpenAI  # pip install openai

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

resp = client.chat.completions.create(
    model="deepseek-r1:14b",
    messages=[
        {"role": "system", "content": "Отвечай на русском."},
        {"role": "user", "content": "Объясни MoE простыми словами."},
    ],
    temperature=0.6,
)
print(resp.choices[0].message.content)

for chunk in client.chat.completions.create(
    model="deepseek-r1:14b",
    messages=[{"role": "user", "content": "Напиши хайку про кита"}],
    stream=True,
):
    print(chunk.choices[0].delta.content or "", end="", flush=True)

import OpenAI from "openai";
const client = new OpenAI({ baseURL: "http://localhost:11434/v1", apiKey: "ollama" });
const r = await client.chat.completions.create({
  model: "deepseek-r1:8b",
  messages: [{ role: "user", content: "Привет!" }],
});
console.log(r.choices[0].message.content);

import requests
r = requests.post("http://localhost:11434/api/chat", json={
    "model": "deepseek-r1:14b",
    "messages": [{"role": "user", "content": "Иван, 29 лет, знает Python и Rust"}],
    "format": {
        "type": "object",
        "properties": {
            "name": {"type": "string"},
            "age": {"type": "integer"},
            "skills": {"type": "array", "items": {"type": "string"}},
        },
        "required": ["name", "age", "skills"],
    },
    "think": False,
    "stream": False,
})
print(r.json()["message"]["content"])  # {"name":"Иван","age":29,"skills":["Python","Rust"]}

Агентам нужна модель с надёжным tool calling и контекстом от 32K: R1 14B+ или V4-Flash.

client = OpenAI(base_url="https://api.deepseek.com", api_key="sk-...")
client.chat.completions.create(model="deepseek-v4-flash", messages=[...])

Модели: deepseek-flash (сейчас ведёт на V4.1-Flash) и deepseek-v4-pro. Старые имена deepseek-chat и deepseek-reasoner выведены из эксплуатации. API также совместим с форматами Anthropic и OpenAI Responses. Цены и актуальные имена смотри на api-docs.deepseek.com.

С октября 2026 у DeepSeek есть официальные Search и Fetch API: поиск по вебу и загрузка страниц в Markdown. Цена — $0.75 за 1000 успешных запросов (пустые и ошибки бесплатно), лимит — 5 запросов/с.

import os, requests
H = {"Authorization": f"Bearer {os.environ['DEEPSEEK_API_KEY']}"}

res = requests.post("https://api.deepseek.com/v1/tools/search", headers=H, json={
    "query": "DeepSeek V4.1 site:huggingface.co after:2026-09-01",
    "count": 5,
}).json()["results"]
for x in res:
    print(x["rerank_score"], x["title"], x["url"])   # + summary, content, date, authority

page = requests.post("https://api.deepseek.com/v1/tools/fetch", headers=H,
                     json={"url": res[0]["url"]}).json()
print(page["content"][:500])                          # Markdown страницы

Операторы запроса: site:, -site:, "фраза", -слово, lang:ru,en, after: и before:.

Фишка: подключи Search как tool к локальному DeepSeek в Ollama. Модель работает у тебя, а свежие факты берутся из веба. Готовый агент: examples/web_search_agent.py.

sequenceDiagram
    participant U as 👤 Пользователь
    participant A as Скрипт-агент
    participant L as Локальный DeepSeek (Ollama)
    participant S as DeepSeek Search API
    U->>A: «Что нового в V4.1?»
    A->>L: вопрос + описание tools
    L-->>A: tool_call web_search("DeepSeek V4.1")
    A->>S: POST /v1/tools/search
    S-->>A: results[] (title, url, summary)
    A->>L: результаты поиска
    L-->>A: ответ + источники
    A-->>U: готовый ответ на русском

📖 Подробнее и больше примеров: docs/07-api-i-integracii.md, examples/

1. Не пиши «думай пошагово»: модель и так рассуждает. Лучше опиши задачу и критерии хорошего ответа.
2. Всё в одном сообщении: сначала контекст, потом задача, в конце формат ответа.
3. Для R1 держи важные инструкции в сообщении пользователя, а системный промпт короткий или пустой.
4. Для математики: «Рассуждай пошагово, итоговый ответ помести в \boxed{}».
5. Few-shot часто мешает reasoning-моделям, поэтому начинай без примеров.
6. Ограничивай длину (num_predict / max_tokens), иначе модель может думать тысячи токенов.
7. Длинный документ ставь в начало, вопрос в конец.

flowchart LR
    Q["Задача"] --> D{"Нужно рассуждать<br/>несколько шагов?"}
    D -->|"Да: код, математика,<br/>логика, анализ"| T["🧠 think: true<br/>temp 0.6 (R1) / 1.0 (V4)"]
    D -->|"Нет: перевод, JSON,<br/>саммари, чат"| N["⚡ think: false<br/>temp 0–0.7"]

Строгий русский язык:

Ты отвечаешь ТОЛЬКО на русском языке, даже если вопрос на другом языке.
Если не знаешь ответа — честно скажи.

Код-ревью:

Проведи ревью кода. Найди: 1) баги, 2) уязвимости, 3) проблемы производительности.
Для каждой: строка, суть, исправленный фрагмент. В конце — оценка 1–10.
<код>
...
</код>

Извлечение данных:

Извлеки все компании и суммы сделок.
Верни ТОЛЬКО JSON-массив [{"company": str, "amount_rub": number}] без пояснений.
Текст: ...

Анализ договора (V4, контекст 1M):

<документ>
...весь договор...
</документ>
Найди пункты, невыгодные Исполнителю. Для каждого: цитата, риск, новая формулировка.

import re
answer = re.sub(r"<think>.*?</think>", "", text, flags=re.S).strip()

В историю диалога клади только answer. Так экономится контекст, и модель не залипает на старых рассуждениях.

📖 Подробнее: docs/08-promptting.md

Две скорости:

• prefill (pp): как быстро модель читает промпт; упирается в вычисления GPU;
• generation (tg): как быстро пишет ответ; упирается в пропускную способность памяти.

Оценка потолка скорости генерации:

токенов/с ≈ пропускная способность памяти (ГБ/с) ÷ размер активных весов (ГБ)

Пример: RTX 4090 (~1000 ГБ/с) с моделью 14B-Q4 (~9 ГБ) в теории даёт ~110 ток/с, на практике 60–80. Для MoE считаются только активные веса, поэтому V4-Flash (13B активных) остаётся быстрой даже частично из RAM.

Порядок величин по замерам сообщества (Q4, короткий контекст, вся модель на GPU, если не сказано иное). Твои цифры будут отличаться. Присылай свои замеры через Issue.

1. ✅ Вся модель на GPU (ollama ps → 100% GPU, в llama.cpp -ngl 99).
2. ✅ Квант поменьше (Q4 вместо Q8) почти линейно ускоряет генерацию.
3. ✅ Для MoE держи экспертов в RAM, а остальное на GPU (-ot ".ffn_.*_exps.=CPU").
4. ✅ Flash attention (-fa on или OLLAMA_FLASH_ATTENTION=1).
5. ✅ KV-кэш в q8_0 освобождает VRAM под слои.
6. ✅ Спекулятивное декодирование (драфтер) даёт 1.5–2× на генерации.
7. ✅ Потоки = физические ядра (на Intel только P-ядра).
8. ✅ Больше батч (-b 2048 -ub 2048) ускоряет длинные промпты.
9. ✅ Неизменный системный промпт: включается кэш префикса.
10. ✅ Для CPU-инференса важна быстрая RAM (DDR5, заняты все каналы).

sudo sysctl iogpu.wired_limit_mb=122880   # пример для Mac со 128 ГБ

Настройка сбрасывается после перезагрузки. Оставь системе 8–16 ГБ.

ollama run deepseek-r1:8b --verbose          # eval rate = токенов/с
llama-bench -m model.gguf -ngl 99 -fa 1      # pp и tg

📖 Подробнее: docs/09-optimizaciya.md

flowchart LR
    subgraph Индексация["📥 Индексация (один раз)"]
        D["PDF, DOCX, MD"] --> C["Чанки<br/>500–1000 токенов"]
        C --> E1["Эмбеддинги<br/>bge-m3"]
        E1 --> V[("Векторная база")]
    end
    subgraph Ответ["💬 Ответ (каждый вопрос)"]
        Q["Вопрос"] --> E2["Эмбеддинг"]
        E2 --> S["Поиск top-k"]
        V --> S
        S --> RR["Реранкер"]
        RR --> P["Промпт + контекст"]
        P --> M["DeepSeek"]
        M --> A["Ответ + источники"]
    end

Без кода: Open WebUI → Workspace → Knowledge → загрузи PDF или DOCX, затем в чате введи # и выбери базу.

На Python: examples/rag_minimal.py

ollama pull bge-m3            # эмбеддинги, хорошо понимают русский
ollama pull deepseek-r1:14b
python examples/rag_minimal.py --docs ./my_docs --question "Какой срок оплаты?"

Как сделать RAG точнее:

• эмбеддинги для русского: bge-m3 или multilingual-e5-large;
• чанки по 500–1000 токенов с перекрытием 10–20%;
• реранкер (bge-reranker-v2-m3) после поиска;
• гибридный поиск (BM25 + векторы) для терминов, артикулов и имён;
• проси модель указывать источник для каждого факта;
• с V4 и контекстом 1M небольшую базу можно положить в промпт целиком, без RAG.

tools = [{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Погода в городе",
    "parameters": {"type": "object",
                   "properties": {"city": {"type": "string"}},
                   "required": ["city"]}
  }
}]
resp = client.chat.completions.create(model="deepseek-r1:14b", messages=msgs, tools=tools)
print(resp.choices[0].message.tool_calls)

Полный цикл «модель → функция → модель»: examples/tool_calling.py.

Паттерн «планировщик + исполнитель»: думающая модель один раз раскладывает задачу на шаги, а быстрая (no-think) выполняет их и вызывает инструменты. Получается дешевле и быстрее.

📖 Подробнее: docs/10-rag-i-agenty.md

Дообучение нужно, когда модель должна усвоить стиль, формат или узкую предметную область. Если задача в том, чтобы модель знала факты из твоих документов, сначала попробуй RAG.

Самый доступный способ: QLoRA через Unsloth на дистилляте R1.

flowchart LR
    A["📝 Датасет JSONL<br/>500–5000 примеров"] --> B["🔧 Unsloth QLoRA<br/>4-бит, r=16"]
    B --> C["🧪 Проверка<br/>на отложенных 10%"]
    C -->|"плохо"| A
    C -->|"хорошо"| D["📦 Экспорт GGUF<br/>Q4_K_M"]
    D --> E["🦙 Ollama<br/>ollama create"]

План:

1. Собери 500–5000 примеров «вопрос → идеальный ответ» в JSONL (для reasoning-моделей с рассуждением).
2. Обучи LoRA-адаптер в Unsloth (есть бесплатные ноутбуки для Colab).
3. Экспортируй в GGUF (model.save_pretrained_gguf(...)).
4. Подключи в Ollama через Modelfile: FROM ./my-model-Q4_K_M.gguf.

📖 Пошагово: docs/13-fine-tuning.md

Память и запуск

1. Квант Q4_K_M по умолчанию, Q5_K_M при запасе памяти, Q8_0 — почти без потерь.
2. Динамические кванты Unsloth (UD-*): важные слои остаются точными, поэтому V4-Flash в 3 битах влезает в ~110 ГБ.
3. Эксперты MoE в RAM: -ot ".ffn_.*_exps.=CPU" позволяет запустить 284B-модель на одной GPU.
4. Явно увеличь контекст в Ollama: OLLAMA_CONTEXT_LENGTH=32768, стандартного не хватает для документов.
5. Сожми KV-кэш: OLLAMA_KV_CACHE_TYPE=q8_0 + OLLAMA_FLASH_ATTENTION=1.
6. OLLAMA_KEEP_ALIVE=-1 убирает задержку перед первым ответом.
7. Mac: sudo sysctl iogpu.wired_limit_mb=… открывает GPU больше памяти.
8. Модели на другой диск: OLLAMA_MODELS=D:\ollama (они занимают десятки гигабайт).

Качество

9. R1: temperature 0.6, а не 0. Иначе модель зацикливается.
10. V4: temperature 1.0, top_p 1.0.
11. R1: инструкции в сообщении пользователя, системный промпт минимальный.
12. Математика: «ответ помести в \boxed{}».
13. Отключай размышления там, где они не нужны: /set nothink, "think": false, --reasoning off.
14. reasoning_effort: "max" у V4 для самых сложных задач (нужен большой контекст).
15. Вырезай <think> из истории диалога.
16. JSON Schema в format даёт гарантированно валидный JSON.
17. Для русского бери 14B+, маленькие дистилляты срываются на английский и китайский.
18. Длинный документ в начало промпта, вопрос в конец.

Скорость

19. Спекулятивное декодирование (DSpark для V4-Flash): 1.5–2×.
20. -ngl 99: каждый слой в RAM сильно замедляет.
21. Потоки = физические ядра, а не логические.
22. --mlock, если система «свопает» модель.
23. vLLM или SGLang для нескольких пользователей: continuous batching даёт кратный прирост.
24. Не меняй системный промпт между запросами, тогда работает кэш префикса.

Интеграции

25. Любой клиент OpenAI работает с локальной моделью через base_url.
26. Continue или Cline в VS Code + DeepSeek дают бесплатного приватного Copilot.
27. Open WebUI + Knowledge — RAG без единой строчки кода.
28. Один код для облака и локалки: меняется только base_url.
29. docker compose up -d поднимает весь стек одной командой.
30. Никогда не открывай порт 11434 в интернет: у API Ollama нет пароля.

flowchart TD
    A(["Медленно 🐢"]) --> B{"ollama ps:<br/>100% GPU?"}
    B -->|"Нет"| C{"Уменьшить контекст<br/>num_ctx помогло?"}
    C -->|"Да"| OK1(["✅ Готово"])
    C -->|"Нет"| D["Квант ниже или<br/>модель меньше"]
    D --> OK1
    B -->|"Да"| E{"Медленный только<br/>первый ответ?"}
    E -->|"Да"| F["OLLAMA_KEEP_ALIVE=-1"]
    F --> OK1
    E -->|"Нет"| G{"Долго «думает»?"}
    G -->|"Да"| H["think: false или<br/>лимит num_predict"]
    H --> OK1
    G -->|"Нет"| I["Flash attention,<br/>KV-кэш q8_0,<br/>спекулятивное декодирование"]
    I --> OK1

📖 Полный разбор: docs/12-troubleshooting.md

• DeepSeek на Hugging Face — официальные веса
• Релиз DeepSeek V4 — официальное объявление
• DeepSeek-V4.1-Flash-1017 — последняя модель (веса, MIT)
• DeepSeek Search и Fetch API — документация
• Ollama — библиотека моделей
• llama.cpp
• Unsloth — гайд по DeepSeek V4
• vLLM · SGLang
• Open WebUI · LM Studio · Jan

Нашёл устаревшую команду, сделал замер скорости на своём железе или знаешь фишку? Открой Issue или PR, подробности в CONTRIBUTING.md.

Тексты — CC BY 4.0, код в examples/ и configs/ — MIT. DeepSeek — торговая марка правообладателя. Проект неофициальный и не связан с DeepSeek-AI.