Ollama: простой способ запустить любую LLM на вашем компьютере

Введение: Когда вам не хочется настраивать Docker-контейнеры

Вы хотите запустить локальную LLM. Гуглите — и вот вам двадцать способов: llama.cpp с компиляцией из исходников, vLLM с настройкой GPU-кластера, Text Generation Inference с кучей зависимостей. Каждый способ рабочий, но каждый требует времени на настройку.

Ollama делает то, что другие инструменты делают с трудом: она просто работает. Одна команда — и через 30 секунд вы общаетесь с Llama 3.2 прямо в терминале. Ещё одна команда — и переключаетесь на Mistral, Qwen или Phi 3.

В этой статье — практическое руководство по Ollama: от установки до production-развёртывания, с примерами кода, настройками и типичными проблемами.

Что такое Ollama и почему она отличается

Ollama — это open-source проект (лицензия MIT), который объединяет три вещи в одном инструменте:

Менеджер моделей — скачивает, кэширует и управляет версиями LLM
Runtime для запуска — оптимизированный движок на основе llama.cpp
API-сервер — REST-совместимый API, совместимый с OpenAI SDK

# Установка
curl -fsSL https://ollama.com/install.sh | sh

# Запуск первой модели
ollama run llama3.2

# Готово. Модель загружена, запущена, и вы можете задавать вопросы.

В чём фишка: Ollama автоматически определяет ваши ресурсы (CPU, GPU, RAM) и выбирает оптимальную конфигурацию. Не нужно вручную настраивать n_gpu_layers, n_ctx или параметры квантования.

Установка на разных платформах

macOS

# Через Homebrew
brew install ollama

# Или установщик с сайта
curl -fsSL https://ollama.com/install.sh | sh

Ollama на macOS использует Apple Metal для GPU-ускорения. Работает на Intel Mac (только CPU) и на M-сериях (GPU + Neural Engine).

Linux

curl -fsSL https://ollama.com/install.sh | sh

# Для NVIDIA GPU — убедитесь, что драйверы и CUDA установлены
nvidia-smi
nvcc --version

# Для AMD GPU — установите ROCm

Windows

Скачайте установщик с ollama.com. Поддерживаются NVIDIA GPU и Intel Arc. AMD Radeon — через ROCm (бета).

Docker

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Docker-версия полезна для CI/CD и серверного развёртывания.

Модели: библиотека, каталог и свои модели

Встроенная библиотека

Ollama поддерживает десятки моделей «из коробки»:

Модель	Размер (Q4_K_M)	Лучшее применение
llama3.2	3.8 ГБ (3B)	Быстрые ответы, CPU
llama3.1	8.0 ГБ (8B)	Баланс скорость/качество
mistral-nemo	7.9 ГБ (12B)	Умный 12B-параметров
qwen2.5	4.4 ГБ (7B)	Код и мультиязычность
phi3	2.2 ГБ (3.8B)	Самый компактный
deepseek-coder-v2	16 ГБ (23B)	Генерация кода
mixtral-8x7b	26 ГБ (47B)	Лучшее качество (нужен GPU с 48GB+)
nemotron	13 ГБ (70B quantized)	70B параметров в квантовании

Просмотр установленных моделей

ollama list

NAME              ID              SIZE      MODIFIED
llama3.2:latest   a09077d7b012      3.6 GB    2 days ago
qwen2.5:7b        86395f30ef58      4.4 GB    1 week ago

Скачивание модели

ollama pull llama3.2
ollama pull qwen2.5:7b-instruct-q4_K_M

Модели кэшируются в ~/.ollama/models. Можно управлять местом:

# Удалить модель
ollama rm llama3.2

# Перенести хранилище
OLLAMA_MODELS=/mnt/big/models ollama serve

Создание своей модели (Modelfile)

Ollama позволяет создавать кастомные модели через Modelfile — текстовый файл с инструкциями:

# Modelfile
FROM llama3.2

# Системный промпт
SYSTEM """Ты — помощник разработчика. Отвечай кратко, с примерами кода.
Если не знаешь ответа — скажи об этом. Не выдумывай API."""

# Параметры
PARAMETER temperature 0.2
PARAMETER num_ctx 8192
PARAMETER stop "### USER:"
PARAMETER stop "### ASSISTANT:"

# Файлы-контекст
COPY ./docs/ /context/docs/

# Создание кастомной модели
ollama create my-assistant -f Modelfile

# Запуск
ollama run my-assistant

Это мощный механизм: можно создать модель, заточенную под конкретную задачу, с фиксированным системным промптом и параметрами.

Интерактивный режим: чат в терминале

ollama run llama3.2
>>> Привет! Кто ты?
>>> Я — Llama 3.2...
>>> Напиши функцию сортировки на Python
>>> Вот реализация алгоритма сортировки слиянием:
>>> ...
>>> /export pdf
>>> /set temperature 0.5
>>> /bye

Команды встроенного CLI

Команда	Описание
`/set key value`	Изменить параметр (temperature, num_ctx, top_p)
`/load name`	Загрузить другую модель без выхода
`/pull name`	Скачать новую модель
`/copy source dest`	Копировать модель (создать алиас)
`/delete name`	Удалить модель
`/clear`	Очистить историю чата
`/export pdf file.pdf`	Экспорт чата в PDF
`/help`	Показать справку

Передача контекста из терминала

# Чат с файлом как с контекстом
cat README.md | ollama run llama3.2 "Проанализируй этот документ: $(cat)"

# Или через pipe
ollama run llama3.2 <<EOF
Вот код функции:
$(cat src/sort.py)

Найди в ней баги.
EOF

API: OpenAI-совместимый интерфейс

Самая мощная сторона Ollama — API. Он совместим с OpenAI Chat Completions API, что значит: любой клиент, написанный для OpenAI, работает с Ollama без изменений (с минимальной правкой base_url).

Базовый запрос

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2",
    "messages": [
      {
        "role": "user",
        "content": "Напиши краткое описание принципа работы бинарного поиска"
      }
    ],
    "temperature": 0.7
  }'

Ответ

{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1714432703,
  "model": "llama3.2",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Бинарный поиск — это алгоритм..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 28,
    "completion_tokens": 156,
    "total_tokens": 184
  }
}

Python: использование с OpenAI SDK

from openai import OpenAI

# Указываем на локальный Ollama вместо OpenAI API
client = OpenAI(
    base_url="http://localhost:11434/v1/",
    api_key="ollama"  # любое значение, не проверяется
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "system", "content": "Ты технический эксперт."},
        {"role": "user", "content": "Объясни разницу между BST и AVL-деревом"}
    ],
    temperature=0.5,
    max_tokens=512
)

print(response.choices[0].message.content)

Python: использование с ollama Python-библиотекой

import ollama

# Простой чат
response = ollama.chat(
    model='llama3.2',
    messages=[
        {'role': 'user', 'content': 'Что такое REST API?'}
    ]
)
print(response['message']['content'])

# С параметрами
response = ollama.chat(
    model='qwen2.5',
    messages=[
        {'role': 'user', 'content': 'Напиши FastAPI-сервер для CRUD операций'}
    ],
    options={
        'temperature': 0.3,
        'num_ctx': 4096
    }
)

JavaScript/TypeScript

const response = await fetch('http://localhost:11434/v1/chat/completions', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model: 'llama3.2',
    messages: [
      { role: 'user', content: 'Напиши рекурсивную функцию факториала на Rust' }
    ],
    temperature: 0.5
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Продвинутые возможности

Stream-режим: потоковая генерация

Для UX с "печатающим" эффектом используйте stream:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2",
    "messages": [{"role": "user", "content": "Расскажи о квантовых вычислениях"}],
    "stream": true
  }'

Ответ приходит по частям (Server-Sent Events):

{"id":"chatcmpl-1","object":"chat.completion.chunk","created":1714432703,"model":"llama3.2","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}
{"id":"chatcmpl-1","object":"chat.completion.chunk","created":1714432703,"model":"llama3.2","choices":[{"index":0,"delta":{"content":"Кван"},"finish_reason":null}]}
{"id":"chatcmpl-1","object":"chat.completion.chunk","created":1714432703,"model":"llama3.2","choices":[{"index":0,"delta":{"content":"товые"},"finish_reason":null}]}
...

Python-обработка стрима:

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Объясни нейросети простыми словами"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Embeddings: векторизация текста для RAG

Ollama поддерживает генерацию эмбеддингов — ключевой компонент для RAG-систем:

curl http://localhost:11434/api/embed \
  -d '{
    "model": "nomic-embed-text",
    "input": ["Что такое RAG?", "Как работает бинарный поиск"]
  }'

{
  "model": "nomic-embed-text",
  "embeddings": [
    [-0.0234, 0.1456, -0.0891, ...],
    [0.0567, -0.0234, 0.1123, ...]
  ],
  "total_tokens": 18
}

Python:

import ollama

response = ollama.embeddings(
    model="nomic-embed-text",
    input="Локальные LLM позволяют обрабатывать данные без отправки в облако"
)
# response['embedding'] — список из 768 чисел

Async embeddings (пакетная векторизация)

curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "Текст для эмбеддинга"
}'

Генерация: не только чат, но и текст

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Опиши архитектуру микросервисов",
  "stream": false
}'

{
  "model": "llama3.2",
  "created_at": "2026-05-04T10:30:00Z",
  "response": "Микросервисная архитектура — это...",
  "done": true,
  "total_duration": 4200000000,
  "load_duration": 1200000000,
  "prompt_eval_count": 15,
  "eval_count": 234,
  "eval_duration": 2800000000
}

Этот эндпоинт возвращает метрики производительности — полезно для бенчмарков.

Настройка и конфигурация

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

Переменная	По умолчанию	Описание
`OLLAMA_HOST`	`0.0.0.0:11434`	Адрес и порт API
`OLLAMA_MODELS`	`~/.ollama/models`	Путь к хранилищу моделей
`OLLAMA_KEEP_ALIVE`	`5m`	Сколько модель остаётся в памяти после запроса
`OLLAMA_DEBUG`	(не установлена)	Уровень отладки
`OLLAMA_NUM_PARALLEL`	`1`	Количество параллельных запросов
`OLLAMA_MAX_LOADED_MODELS`	`1`	Максимум моделей в памяти одновременно

Keep-Alive: управление памятью

По умолчанию модель остаётся в памяти 5 минут после последнего запроса. Это значит: следующий запрос будет мгновенным, без повторной загрузки.

# Модель остаётся в памяти 30 минут
ollama run --keep-alive 30m llama3.2

# Модель выгружается сразу после ответа
ollama run --keep-alive 0 llama3.2

# API: модель не выгружается никогда (пока сервер работает)
curl http://localhost:11434/v1/chat/completions \
  -d '{"model": "llama3.2", "keep_alive": -1, ...}'

Для production: установите OLLAMA_KEEP_ALIVE=-1 или большое значение, чтобы модели не выгружались.

Ограничение GPU-ресурсов

# Использовать только 1 GPU из нескольких
CUDA_VISIBLE_DEVICES=0 ollama serve

# Ограничить VRAM (через OLLAMA_MAX_LOADED_MODELS и размер моделей)

Конфигурационный файл

Ollama не использует YAML/JSON конфиг. Вся настройка — через переменные окружения и флаги при запуске. Это осознанный дизайн-выбор: меньше файлов конфигурации — меньше возможностей что-то сломать.

Ollama как фронтенд для llama.cpp

Под капотом Ollama использует llama.cpp. Это значит:

Все модели в формате GGUF работают с Ollama
Параметры квантования применяются автоматически
Вы можете использовать Ollama как удобный интерфейс к мощностям llama.cpp

# Ollama автоматически выбирает:
# - n_gpu_layers (все слои на GPU, если доступен)
# - n_ctx (4096 по умолчанию, расширяется до num_ctx)
# - flash_attn (если GPU поддерживает)
# - mmap (memory-mapped I/O для быстрой загрузки)

Если нужно тонко настроить — используйте Modelfile:

FROM llama3.1:8b

# Переопределение параметров llama.cpp
PARAMETER num_ctx 16384
PARAMETER num_gpu_layers 35
PARAMETER num_batch 512
PARAMETER num_thread 8
PARAMETER flash_attention

RAG с Ollama: векторная БД и локальный контекст

Ollama сама по себе не является RAG-фреймворком, но отлично работает с ними.

С LangChain

from langchain_community.llms import Ollama
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import OllamaEmbeddings
from langchain.chains import RetrievalQA

# Эмбеддинги через Ollama
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Векторная БД
vectorstore = Chroma(
    persist_directory="./rag_db",
    embedding_function=embeddings
)

# LLM через Ollama
llm = Ollama(
    model="llama3.2",
    temperature=0.1,
    num_ctx=8192
)

# RAG-цепочка
retriever = vectorstore.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={"k": 4, "score_threshold": 0.65}
)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    chain_type="stuff"
)

answer = qa_chain.invoke("Как настроить квантование моделей?")
print(answer["result"])

С LlamaIndex

from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Загрузка документов
documents = SimpleDirectoryReader("./docs").load_data()

# Ollama как LLM и embedding модель
llm = Ollama(model="llama3.2", request_timeout=60.0)
embed_model = OllamaEmbedding(model_name="nomic-embed-text")

# Индекс
index = VectorStoreIndex.from_documents(documents, embed_model=embed_model)

# Запрос
query_engine = index.as_query_engine(llm=llm)
response = query_engine.query("Какие требования к GPU для запуска 70B моделей?")
print(response)

Управление несколькими моделями

Копирование и алиасы

# Создать копию модели с другим именем
ollama cp llama3.2 my-assistant

# Изменить системный промпт
ollama edit my-assistant
# Откроется редактор с Modelfile

Параллельные модели

# Ollama поддерживает несколько моделей одновременно
# (если хватает RAM/VRAM)

OLLAMA_MAX_LOADED_MODELS=3 ollama serve

# Запросы к разным моделям параллельно
curl http://localhost:11434/v1/chat/completions -d '{"model": "llama3.2", ...}' &
curl http://localhost:11434/v1/chat/completions -d '{"model": "qwen2.5", ...}' &

Роутинг запросов по моделям

from openai import OpenAI

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

def smart_ask(question: str, model: str = "auto") -> str:
    """Выбирает модель на основе типа вопроса."""
    models = {
        "fast": "llama3.2:3b",
        "smart": "mixtral-8x7b",
        "code": "deepseek-coder-v2:16b",
        "auto": None  # автовыбор
    }

    if model == "auto":
        if "код" in question.lower() or "function" in question.lower():
            model = "code"
        elif len(question.split()) > 20:
            model = "smart"
        else:
            model = "fast"

    response = client.chat.completions.create(
        model=models[model],
        messages=[{"role": "user", "content": question}]
    )
    return response.choices[0].message.content

Производительность и бенчмарки

Что влияет на скорость

Фактор	Влияние
Размер модели	7B ≈ в 2.5x быстрее 23B
Квантование	Q4_K_M ≈ в 2x быстрее F16, с минимальной потерей качества
num_ctx	Больше контекст = медленнее evaluation
GPU	VRAM 8GB ≈ 30 tok/s (8B), VRAM 24GB ≈ 80 tok/s (8B)
num_thread	На CPU: установите равным кол-ву физических ядер

Бенчмарк: скорость генерации (tok/s)

Тестовая машина: MacBook Pro M2 Max, 64GB RAM

Модель	CPU	GPU (Metal)
llama3.2 3B	25 tok/s	95 tok/s
llama3.1 8B	12 tok/s	45 tok/s
qwen2.5 7B	14 tok/s	52 tok/s
nemotron 70B (Q4)	3 tok/s	12 tok/s

Мониторинг в реальном времени

# Посмотреть активные модели и загрузку
curl http://localhost:11434/api/tags | jq '.models'

# Статистика по запросам (через логи)
tail -f ~/.ollama/logs/ollama.log

Ollama в production

Развёртывание на сервере

# Установка на удалённом сервере
ssh server "curl -fsSL https://ollama.com/install.sh | sh"

# Запуск как systemd-сервис
sudo systemctl enable ollama
sudo systemctl start ollama

# Проверка
curl http://localhost:11434/api/tags

Docker Compose для продакшена

version: '3.8'

services:
  ollama:
    image: ollama/ollama
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

  # Пример: фронтенд с WebUI
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui-data:/app/backend/data
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama-data:
  open-webui:

Open WebUI: готовый веб-интерфейс

Open WebUI — полноценный веб-интерфейс (аналог ChatGPT) для Ollama:

docker run -d -p 3000:8080 \
  -e OLLAMA_BASE_URL=http://localhost:11434 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

Откройте http://localhost:3000 — получите полноценный чат-интерфейс с:

Историей диалогов
Поддержкой нескольких моделей
Загрузкой файлов для анализа
RAG из коробки
Системой пользователей и ролей

Типичные проблемы и решения

Проблема 1: «Модель не загружается на GPU»

warning: some weights are not device assigned.

Решение:

# Проверьте, что GPU обнаружен
nvidia-smi

# Убедитесь, что CUDA работает
ollama --version

# Перезапустите сервис
sudo systemctl restart ollama

# Для macOS — убедитесь, что macOS 13.5+

Проблема 2: «Не хватает памяти»

OutOfMemory: failed to map...

Решение:

# Уменьшите num_ctx
ollama edit llama3.2
# PARAMETER num_ctx 4096

# Выгрузите неиспользуемые модели
ollama stop <model-name>

# Уменьшите OLLAMA_MAX_LOADED_MODELS
OLLAMA_MAX_LOADED_MODELS=1 ollama serve

Проблема 3: «API отвечает 404 на /v1/...»

Решение: Убедитесь, что используете правильный URL:

# Старый API (работает, но /v1/ предпочтительнее для совместимости)
curl http://localhost:11434/api/generate

# Новый OpenAI-совместимый API
curl http://localhost:11434/v1/chat/completions

Проблема 4: «Модель выгружается между запросами»

Решение:

# Установите большое keep-alive значение
OLLAMA_KEEP_ALIVE=24h ollama serve

# Или в запросе API:
curl http://localhost:11434/v1/chat/completions \
  -d '{"model": "llama3.2", "keep_alive": 3600, ...}'

Проблема 5: «Медленная генерация на CPU»

Решение:

# Уменьшите num_ctx
PARAMETER num_ctx 2048

# Увеличьте num_thread (до кол-ва физических ядер)
PARAMETER num_thread 8

# Используйте более маленькую модель
ollama pull llama3.2:3b

Ollama vs llama.cpp vs vLLM: что выбрать

Критерий	Ollama	llama.cpp	vLLM
Сложность установки	⭐ Одна команда	⭐⭐⭐ Компиляция	⭐⭐⭐ Зависимости
Поддержка GPU	NVIDIA, AMD, Apple Metal	NVIDIA, AMD, Apple Metal	NVIDIA только
Мульти-модели	Да (параллельно)	Ручное управление	PagedAttention
API	OpenAI-совместимый	HTTP API	OpenAI-совместимый
RAG из коробки	Нет (через библиотеки)	Нет	Нет
WebUI	Open WebUI	llama.cpp server	NeMo-Runner
Production	Docker, systemd	Сервер	Kubernetes
Лучший для	Быстрый старт, разработка	Встраивание в приложения	Высоконагруженный production

Правило выбора:

Начинаете или прототипируете? → Ollama
Встраиваете LLM в приложение на C/Rust/Go? → llama.cpp
Production с 1000+ RPS на NVIDIA GPU? → vLLM

Экосистема вокруг Ollama

Инструменты

Инструмент	Описание	Ссылка
Open WebUI	Веб-интерфейс типа ChatGPT	github.com/open-webui/open-webui
Open WebUI Apps	Мобильные приложения	App Store, Google Play
Cherry Studio	Desktop-клиент (Mac/Win/Linux)	cherry-ai.com
Enchanted	macOS-клиент	github.com/AugustDev/enchanted
LibreChat	Агрегатор AI-сервисов	github.com/danny-avila/librechat
Open WebUI Functions	Плагины для Ollama	docs.openwebui.com

Интеграции

Ollama интегрируется с:

VS Code — расширение Continue.dev для AI-ассистента в IDE
Zed — редактор с AI-поддержкой через Ollama
Obsidian — плагин для работы с базой знаний через локальную LLM
Raycast — macOS-лаунчер с AI-поиском
Alfred — аналог Raycast для macOS

Заключение: Ollama — стандарт де-факто для локальных LLM

Ollama решает главную проблему локальных LLM: сложность запуска. Она не пытается быть всем инструментом сразу — она делает три вещи идеально:

Управление моделями — скачивание, кэширование, версионирование
Запуск — оптимизированный runtime с автоматическим выбором конфигурации
API — совместимый с экосистемой OpenAI

Ключевые выводы:

Начните с Ollama. Даже если потом перейдёте на vLLM или llama.cpp — начинайте с Ollama для быстрого прототипирования.
Используйте Open WebUI. Готовый веб-интерфейс экономит часы разработки.
nomic-embed-text + llama3.2 — ваш стартовый стек. Для RAG и чата этого хватит на первое время.
OLLAMA_KEEP_ALIVE — ваш друг. Для серверного использования установите большое значение.
Modelfile — недооценённая фича. Кастомные модели с фиксированным промптом — это мощно.

# Ваш первый шаг:
curl -fsSL https://ollama.com/install.sh | sh
ollama run llama3.2

Через 2 минуты у вас будет работающая локальная LLM. Без Docker, без компиляции, без зависимостей.

Дополнительные ресурсы

Ollama Documentation — официальный блог и документация
Ollama API Reference — полная спецификация API
Open WebUI — веб-интерфейс для Ollama
Ollama Library — полная библиотека моделей
Ollama Python Library — официальная Python-библиотека
Continue.dev — AI-ассистент в IDE с поддержкой Ollama