llama.cpp против Ollama в 2026 году: какой рантайм выбрать?

Ollama и llama.cpp часто сравнивают, будто бы это конкурирующие движки вывода. Настоящий выбор — между управляемым сервисом моделей и набором инструментов, которым вы управляете напрямую.

Ollama оборачивает зафиксированную и пропатченную версию llama.cpp в планировщик, хранилище моделей и API, так что именованная модель становится единицей, которой вы управляете. Прямой llama.cpp инвертирует это: процесс llama-server и его флаги становятся единицей, и каждый выбор относительно контекста, KV-кэша и размещения на GPU — это то, что делаете вы и можете показать в команде.

Это руководство сравнивает два инструмента так, как реально происходит принятие решения: установка и повседневные команды, управление моделями и их жизненный цикл, управление рантаймом, API, производительность, режимы отказов и безопасность. В конце приводятся конкретные триггеры для сохранения Ollama, перехода на llama-server и путь низко рисковой миграции между ними. Если вы все еще выбираете между локальным, self-hosted и облачным подходами на более высоком уровне, начните с Обзора хостинга LLM; для более широкого обзора локальных инструментов за пределами этой пары, сравнение локального хостинга LLM охватывает vLLM, LM Studio, LocalAI и многое другое.

llama.cpp против Ollama: краткий ответ

Если вам нужна только надежная подсистема для Open WebUI, ассистента кодинга или нескольких локальных скриптов, Ollama обычно является менее отвлекающим выбором. Если вы постоянно спрашиваете, что Ollama выбрало, выделило, изменило или скрыло, вероятно, вы достигли точки, где llama-server является более чистой системой.

Что означает сравнение на самом деле в 2026 году

llama.cpp — это проект вывода на C и C++ с бэкендами для CPU и GPU, инструментами для GGUF-моделей, консольными программами и HTTP-сервером. Его программа прямого обслуживания поддерживает совместимые с OpenAI Chat Completions, Responses, эмбеддинги, мультимодальные запросы, вызов функций, структурированный вывод, непрерывную пакетизацию, спекулятивное декодирование, эндпоинты мониторинга и встроенный веб-интерфейс.

Ollama — это сервис более высокого уровня. Он поддерживает локальное хранилище моделей, дает моделям стабильные имена, скачивает и импортирует артефакты, применяет шаблоны и значения по умолчанию, выбирает доступный бэкенд, планирует процессы моделей и выгружает бездействующие модели. Его нативный API также сообщает временные метки и информацию о загрузке, что удобно для локальных приложений.

Часто повторяемое утверждение, что «Ollama — это просто обертка над llama.cpp», полезно по направлению, но технически неполно. Ollama фиксирует исходный код llama.cpp, применяет патчи совместимости и запускает сервер через собственный планировщик, но у него также есть продуктовое поведение, которое llama.cpp не определяет; на Apple silicon Ollama может использовать свой движок MLX. Путь запроса делает разницу конкретной:

Это приводит к наиболее полезной ментальной модели:

• В Ollama именованная модель — это единица, которой вы управляете.
• В прямом llama.cpp процесс сервера и его флаги — это единица, которой вы управляете.

Установка и повседневный набор команд

Ollama оптимизирует первые пять минут. После установки, получение и запуск модели намеренно лаконичны:

ollama run qwen3:8b

Имя модели обозначает больше, чем просто веса. Ollama может связать с этим именем шаблон, параметры, системный промпт, лицензию, адаптер и минимальную версию рантайма. ollama list, ollama show, ollama ps и ollama stop обеспечивают согласованную поверхность управления.

Прямой llama.cpp стартует ближе к «металлу». Вы можете скачать бинарный релиз, собрать версию для конкретного бэкенда, использовать контейнер или использовать более новый путь загрузки с Hugging Face, как описано в быстром старте llama.cpp. Локальный GGUF-сервер может стартовать так:

llama-server \
  --model /srv/models/qwen3-8b-q4_k_m.gguf \
  --alias qwen3-8b \
  --host 127.0.0.1 \
  --port 8080 \
  --ctx-size 32768 \
  --n-gpu-layers all \
  --flash-attn on

Текущая документация llama.cpp также показывает объединенную команду llama serve в своем быстром старте. Имена упакованных исполняемых файлов могут варьироваться в зависимости от дистрибутива, поэтому проверяйте релиз или пакет, который вы установили, а не копируйте файл службы слепо.

Длинная команда не является автоматически недостатком. Это исполняемая запись того рантайма, который вы намеревались создать. Поместите его в unit systemd, файл Compose или shell-скрипт, и конфигурация станет проверяемой, вместо того чтобы быть разбросанной по манифесту модели, переменным окружения, опциям API и значениям по умолчанию планировщика.

Практический компромисс при установке

Ollama проще установить единообразно на машинах разработчиков. Также его проще объяснить человеку, который должен использовать модель, но не должен разбираться в выгрузке тензоров, шаблонах чата или KV-памяти.

llama.cpp проще сделать точным. Вы выбираете сборку, бэкенд, версию, файл и флаги, что ценно, когда новое GPU-ядро исправляет вашу рабочую нагрузку или недавний коммит ее ломает. Эта свобода также означает, что вы несете ответственность за обновления, надзор за сервисом и тестирование регрессий.

Управление моделями: имена библиотек или обычные файлы

Ollama относится к моделям скорее как к образам контейнеров. Знакомое имя указывает на манифест и blobs с адресацией по содержимому, и ollama pull разрешает необходимые слои. Это превосходно для повторяемой настройки рабочих станций и для приложений, которые должны ссылаться на qwen3:8b, а не на длинный путь файловой системы.

Modelfile делает кастомизацию воспроизводимой:

FROM ./qwen3-8b-q4_k_m.gguf
PARAMETER num_ctx 32768
PARAMETER temperature 0.7
PARAMETER top_p 0.9
SYSTEM You are a precise technical assistant.

ollama create qwen3-8b-local -f Modelfile
ollama run qwen3-8b-local

Ollama может импортировать локальный GGUF, поэтому выбор Ollama не ограничивает вас публичной библиотекой Ollama. Однако шаг импорта передает артефакт в хранилище моделей Ollama. Если вы также сохраняете оригинальный GGUF для llama.cpp или LM Studio, учитывайте дополнительную управляемую копию, если ваш слой хранения не дедуплицирует ее.

llama.cpp может просто указывать на GGUF, который у вас уже есть. Он также может скачать выбранную квантизацию с Hugging Face:

llama-server -hf ggml-org/Qwen3-8B-GGUF:Q4_K_M

Этот файловый подход особенно хорошо работает для тестирования новых квантизаций. Скачайте файл, измените один путь и запустите; нет шага создания и нет вопроса о том, к какому blob разрешается имя модели.

Шаблоны являются частью модели, даже когда они выглядят как конфигурация

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

Кураторская библиотека Ollama снижает этот риск, потому что его именованные модели несут протестированные метаданные, и текущие релизы (Ollama перешла с 0.30 на 0.33.3 между июнем и сентябрм 2026 года) все больше уважают параметры по умолчанию, определенные в GGUF, напрямую, а не требуя от вас повторять их в Modelfile. Ручной импорт GGUF может все еще нуждаться в правильном TEMPLATE, парсере или рендерере, тогда как llama.cpp обычно читает встроенный шаблон чата GGUF и позволяет вам переопределить его. Ни один рантайм не может исправить неправильные или отсутствующие метаданные модели магией.

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

Жизненный цикл моделей и переключение

Планировщик Ollama — одна из его самых сильных причин для существования. По умолчанию бездействующая модель остается загруженной в течение пяти минут; значение keep_alive на уровне запроса может держать ее резидентной неопределенное время, изменить длительность или выгрузить ее немедленно. ollama ps показывает загруженные модели, размещение на процессорах, выделение контекста и срок истечения.

# Держать модель загруженной.
curl http://localhost:11434/api/generate -d '{
  "model": "qwen3:8b",
  "keep_alive": -1
}'

# Выгрузить ее немедленно.
curl http://localhost:11434/api/generate -d '{
  "model": "qwen3:8b",
  "keep_alive": 0
}'

Традиционный процесс llama-server --model ... загружает одну модель и держит ее до выхода процесса. Это поведение невероятно предсказуемо для специализированного сервиса: нет неожиданной холодной загрузки после таймаута простоя и нет планировщика, решающего, что другая модель заслуживает памяти.

llama.cpp теперь также имеет режим роутера. Запуск llama-server без модели может экспонировать кешированные модели, каталог GGUF или пресеты INI и динамически загружать экземпляры согласно запрашиваемому имени модели. Он закрывает старый пробел в жизненном цикле только частично: только одна модель резидентна на рабочий процесс за раз, переключение — это полная выгрузка и перезагрузка, а не мгновенное, и нет политики вытеснения или теплой пулы — каждый чередующийся запрос между двумя моделями платит полной перезагрузкой. Это сужает разницу с отсутствием режима роутера вообще, но не делает два продукта идентичными; Ollama все еще предоставляет более плавный реестр, теплую пулу и опыт администрирования. Для полного обзора конфигурации, текущих ограничений и честного сравнения с Ollama и llama-swap, посмотрите руководство по режиму роутера llama-server. Если вам нужен один эндпоинт для llama.cpp, vLLM, SGLang и других движков, llama-swap является более подходящей абстракцией, чем заставлять любой из рантаймов становиться универсальным прокси моделей.

Управление рантаймом: где llama.cpp окупает дополнительную работу

Решающее преимущество llama.cpp заключается не в том, что он всегда быстрее. Оно в том, что вы можете непосредственно выразить план памяти и выполнения, осмотреть его и изменить одну переменную за раз.

Точность контекста и KV-кэша

Для прямого llama.cpp размер контекста и типы K/V кэша можно установить для каждого процесса сервера:

llama-server \
  --model model.gguf \
  --ctx-size 65536 \
  --cache-type-k q8_0 \
  --cache-type-v q8_0 \
  --parallel 2 \
  --flash-attn on

K и V могут использовать разные типы, и llama.cpp предоставляет дополнительные контролы для унифицированного выделения KV, лимитов контекста на слот, повторного использования кэша промпта и персистентности кэша. Эти флаги не являются декоративными на GPU с 16 ГБ или 32 ГБ — они определяют, помещаются ли запросы с длинным контекстом и сколько слотов могут оставаться полезными, и базовая математика бюджета VRAM одинакова независимо от того, какой рантайм ее применяет; см. KV-кэш на GPU 16 ГБ для формулы и таблиц типов кэша для каждого движка.

Ollama экспонирует важный общий случай с помощью OLLAMA_CONTEXT_LENGTH, опции num_ctx и OLLAMA_KV_CACHE_TYPE. Однако его тип KV-кэша является настройкой для всего сервера, а не выбором для каждого именованного модели. Ollama также масштабирует память с настроенной параллельностью и длиной контекста, что может сделать безобидно выглядящее изменение конкурентности потребляющим гораздо больше VRAM.

Это поведение преимущественно описано в руководстве по параллельным запросам Ollama. Для этого сравнения решение проще: используйте Ollama, когда глобальная политика кэша приемлема; используйте отдельные сервисы llama.cpp, когда разным моделям нужна разная точность кэша, контекст или геометрия слотов.

Выбор GPU и размещение на нескольких GPU

Ollama стремится выбрать разумное размещение. Он сообщает, находится ли модель полностью на GPU, полностью на CPU или разделена, и его планировщик учитывает доступную память при загрузке моделей. Для обычной рабочей станции с одним GPU автоматическое размещение часто является именно тем, что вам нужно.

llama.cpp экспонирует план. Вы можете выбирать устройства, указывать слои GPU, выбирать режимы распределения по слоям, строкам или экспериментальные тензорные режимы, устанавливать пропорции тензоров, выбирать основной GPU и сознательно держать веса экспертов MoE на CPU. Это существенно лучше для асимметричных машин с несколькими GPU и для втискивания перегабаритной модели в известный бюджет памяти.

Если ваши операционные заметки содержат фразы вроде «положите KV-кэш на эти устройства» или «держите только экспертов в системной RAM», прямой llama.cpp является естественным инструментом. Если требование просто «используйте GPU, если помещается», Ollama экономит время, не отдавая много.

Новые функции и частота обновлений бэкендов

Прямой llama.cpp — это место, где впервые появляются новые архитектуры моделей llama.cpp, типы квантизации, GPU-ядра и экспериментальные опции сервера. Это ценно в неделю релиза модели, когда поддержка может зависеть от конкретного номера сборки, а не последнего стабильного пакета.

Ollama намеренно фиксирует upstream-ревизию и применяет патчи совместимости. Это может задержать upstream-функцию, но также может защитить пользователей от изменений и интегрировать ее с планировщиком Ollama, шаблонами и кроссплатформенной упаковкой. Более быстрый доступ — это не то же самое, что большая надежность.

Ollama 0.30 существенно сократил старый разрыв, расширив совместимость с GGUF, улучшив производительность NVIDIA и включив Vulkan по умолчанию для более широкой поддержки AMD и Intel. Частота релизов Ollama с тех пор осталась высокой — 0.33.3 вышел в начале сентября 2026 года, примерно через три месяца, добавив отчетность о кешированных токенах промпта и еще один bump бэкенда llama.cpp, — поэтому относитесь к любому конкретному утверждению о версии в этой статье или где-либо еще как к чему-то, что нужно перепроверять по ollama --version, а не как к постоянному факту. Любое сравнение, говорящее, что Ollama не может запустить произвольный локальный GGUF, или что Vulkan всегда требует экспериментального оп-ина, теперь устарело.

API, инструменты, зрение и структурированный вывод

Оба рантайма являются достоверными локальными API-серверами в 2026 году. Оба могут обрабатывать общие чат-запросы в стиле OpenAI, инструменты, модели со способностью зрения, эмбеддинги, стриминг и структурированный вывод, если модель и шаблон это поддерживают.

Разница в окружающем интерфейсе:

Не относитесь к «совместимому с OpenAI» как к бинарной сертификации. Ollama заявляет, что поддерживает части API OpenAI, тогда как llama.cpp явно избегает做强ного обещания совместимости. Перед сменой рантаймов протестируйте стриминговые кадры, аргументы вызова инструментов, поля рассуждений, счетчики использования, тела ошибок и любой эндпоинт, который ваш клиент фактически потребляет.

Ollama обычно побеждает, когда интеграция приложения является задачей. Его SDK и задокументированные интеграции делают счастливый путь коротким. llama.cpp побеждает, когда сам сервер является объектом инжиниринга: его вид слотов, временные метки токенов, метрики, схемы, шаблоны, адаптеры и низкоуровневые эндпоинты необычно полезны при диагностике.

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

Темптуещно спросить, что быстрее — llama.cpp или Ollama. На пути GGUF Ollama может запускать зафиксированную и пропатченную llama.cpp под капотом, поэтому универсальный ответ на уровне бренда не полезен. Результаты меняются в зависимости от ревизии сборки, бэкенда, flash attention, выделения контекста, параллельных слотов, размеров батчей, типа кэша, резидентности модели и того, упали ли некоторые слои на CPU.

Честное сравнение начинается с одного и того же GGUF и тестировать два разных вопроса:

1. Холодный старт: включать время загрузки модели и латентность первого ответа.
2. Теплый сервис: предварительно загрузить модель, затем измерить обработку промпта и генерацию отдельно.

Используйте один запрос и один слот сначала. Совпадите в размере контекста, типе K/V кэша, температуре, top-p, seed, максимальном выводе и шаблоне чата; подтвердите полное выгружение на GPU из логов или вывода статуса. Только тогда увеличивайте конкурентность, потому что Ollama и llama.cpp выделяют и планируют параллельную работу по-разному.

Для Ollama конечный ответ нативного API включает длительности загрузки, оценки промпта и генерации, и текущие релизы также сообщают о кешированных токенах промпта напрямую в этом ответе — полезно для подтверждения, произошло ли повторное использование префикса, прежде чем приписывать выигрыш в скорости рантайму. Для llama.cpp включите отчетность о производительности или метрики Prometheus и осмотрите конфигурацию запуска. Пятипроцентный выигрыш в пропускной способности бессмысленен, если один запуск молча использовал более короткий контекст, другой тип кэша или другой шаблон.

Мой прогноз для той же поддерживаемой GGUF на одном GPU обычно близок к паритету, а не гарантированной победе llama.cpp. Прямой llama.cpp может выиграть после намеренной настройки или внедрения новой оптимизации; Ollama может быть таким же быстрым, когда его выбранный движок и значения по умолчанию совпадают с рабочей нагрузкой. Измеряйте после конфигурации, а не до.

Режимы отказов, которые выявляют настоящую разницу

Модель неожиданно использует CPU

В Ollama запустите ollama ps и осмотрите PROCESSOR, CONTEXT и загруженный размер. Более крупный контекст, другая резидентная модель или неподдерживаемый путь GPU могут объяснить разделение. Проверяйте логи сервиса, а не предполагайте, что GPU было проигнорировано.

В llama.cpp начните с llama-server --list-devices, затем читайте журнал запуска для размещения тензоров и размеров буферов. Если вы установили точное количество слоев, устройство или разделение, сама команда является доказательством вашего намерения; это гораздо проще воспроизвести в отчете об ошибке.

Более длинный контекст вызывает ошибку переполнения памяти

Ollama выбирает длины контекста по умолчанию согласно доступной VRAM, и текущая документация рекомендует минимум 64K для агентных и кодинг рабочих нагрузок. Эта рекомендация не является обещанием, что ваша модель, параллельность и кэш поместятся. Уменьшите num_ctx, уменьшите параллельность, выберите KV-кэш q8_0 где уместно, или используйте меньшую квантизацию весов. Подтвердите фактическую картину памяти с помощью nvidia-smi до и после длинного запроса, чтобы знать, является ли ограничением модель, кэш или оба.

В llama.cpp уменьшите --ctx-size, измените --cache-type-k и --cache-type-v, снизьте --parallel или отрегулируйте выгружение. Поскольку каждый выбор явный, проще построить отдельные профили для длинного контекста и высокой конкурентности, а не заставлять один компромисс применяться ко всем моделям.

API подключается, но ответы сформированы неправильно

Часто это проблема шаблона или парсера, особенно с новыми моделями рассуждений и вызова инструментов. Убедитесь, что GGUF содержит ожидаемый шаблон чата и что рантайм распознает архитектуру. Сравните простой чат-запрос, прежде чем отлаживать агентный фреймворк, лежащий поверх.

В Ollama осмотрите ollama show --modelfile <name> и сообщенные возможности. В llama.cpp осмотрите сообщения шаблона при старте, используйте --jinja и протестируйте /v1/chat/completions напрямую. Зафиксируйте рабочую версию рантайма, прежде чем изменять другую переменную.

Запросы становятся медленными после переключения моделей

Ollama может понадобиться выгрузить одну модель и загрузить другую, поэтому разделяйте время ожидания в очереди и время генерации. Предварительно загрузите важную модель пустым запросом и установите намеренное значение keep_alive, а не полагайтесь на пятиминутное значение по умолчанию.

Специализированный процесс llama.cpp избегает неожиданного переключения, потому что его модель остается резидентной. Если вы принимаете режим роутера, загрузка модели снова становится динамической — и каждое переключение между двумя разными моделями является полной выгрузкой и перезагрузкой без теплой пулы — поэтому отслеживайте состояние загрузки и латентность холодного старта так же, как с Ollama.

Безопасность не является дифференциатором, пока вы ее не настроите

Оба сервера привязываются к localhost по умолчанию, что является правильным поведением для рабочей станции. Изменение host на 0.0.0.0 превращает частный локальный сервис вывода в сетевой сервис, и ни один продукт не должен быть экспонирован в публичный Интернет просто потому, что правило файрвола случайно это позволило.

llama.cpp может выполнять API-ключи и завершать TLS, хотя обратный прокси все еще полезен для политик, ограничений частоты и логов. Локальный API Ollama не требует API-ключ; поместите его за аутентифицированным прокси или границей частной сети, если удаленным клиентам нужен доступ. Если вам действительно нужен удаленный доступ к Ollama, руководство по Ollama за обратным прокси охватывает настройку Caddy и Nginx с проверками стриминга и таймаутов. Модели со способностью к инструментам увеличивают последствия экспонирования окружающего приложения, даже когда сам сервер вывода не выполняет инструменты.

Когда сохранять Ollama

Сохраняйте Ollama, когда его автоматизация убирает больше работы, чем скрывает. Он особенно силён для общих рабочих станций разработчиков, локальных настольных приложений, демонстраций, инструментов кодинга и небольших сервисов, которые переключаются между несколькими популярными моделями.

Ollama также является лучшим вариантом по умолчанию, когда вы хотите, чтобы коллеги воспроизвели именованную конфигурацию, не изучая флаги llama.cpp. Modelfile, тег модели и две команды являются полезным операционным контрактом. Шпаргалка по Ollama охватывает этот повседневный рабочий процесс более подробно.

Не мигрируйте просто потому, что прямой llama.cpp выглядит более техническим. Если ваша модель помещается, API работает корректно, латентность стабильна и вам не нужен отсутствующий контрол, замена Ollama создает обслуживание, не создавая возможностей.

Одно предостережение, за которым стоит следить со временем: собственное продуктовое направление Ollama начало дрейфовать в сторону централизованной инфраструктуры. Ollama Turbo — это облачный ускоритель, требующий входа, наложенный поверх того, что первоначально было локально-первичным и приватно-первичным инструментом, и это не единственное недавнее изменение, которое меняет локальный контроль на хостинговый слой удобства. Если причина, по которой вы выбрали Ollama в первую очередь, заключалась в том, чтобы избежать отправки промптов на серверы кого-то другого, этому обоснованию нужна периодическая проверка, а не разовое решение — см. Дегреляция Ollama: Первые признаки для конкретных изменений и того, за чем следить. У прямого llama.cpp нет эквивалентного хостингового апселла, к которому можно дрейфовать, что само по себе является точкой данных, когда вы взвешиваете долгосрочный контроль против краткосрочного удобства.

Когда переходить на llama-server

Переходите на прямой llama-server, когда одно или несколько из этих утверждений верно:

• Вам нужна новая функция llama.cpp или исправление модели до того, как оно дойдет до Ollama.
• Вы должны зафиксировать точный коммит llama.cpp и сборку бэкенда.
• Разным моделям нужны разные типы кэша K и V или раскладки слотов.
• Вам нужно намеренное размещение на нескольких GPU, а не автоматический выбор.
• Вы тестируете спекулятивное декодирование, MTP, масштабы LoRA, кэширование промпта или необычные сэмплеры.
• Нативные метрики, состояние слотов или внутренности сервера необходимы для диагностики.
• Вы хотите, чтобы оригинальные GGUF-файлы оставались авторитетным каталогом моделей.
• Модель должна оставаться резидентной на протяжении жизненного цикла одного наблюдаемого процесса.

Самый чистый триггер для миграции — повторяющаяся инспекция. Если каждый инцидент начинается с обнаружения того, что выбрало Ollama, прежде чем вы можете диагностировать модель, сделайте эти выбора явными в определении сервиса llama.cpp.

Низко рисковая миграция с Ollama на llama.cpp

Не начинайте с воспроизведения каждой функции Ollama. Мигрируйте одну модель и одного клиента, сохраняйте текущий эндпоинт, пока сравнение не будет завершено, и сохраняйте тот же GGUF, если возможно.

1. Запишите ollama --version, ollama show <model>, ollama show --modelfile <model> и ollama ps.
2. Найдите или скачайте эквивалентный GGUF и любой мультимодальный проектор.
3. Запустите один llama-server с явным псевдонимом, контекстом, выгружением на GPU, типами кэша и количеством слотов.
4. Отправьте простой чат-запрос, запрос структурированного вывода и вызов инструмента напрямую каждому API.
5. Протестируйте реального клиента, включая стриминг и обработку ошибок.
6. Сравните латентность холодной загрузки, скорость теплого промпта, скорость генерации, VRAM и формат ответа.
7. Только тогда заменяйте URL сервиса или добавляйте прокси перед обоими бэкендами.

Для простого дымового теста в стиле OpenAI:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "qwen3-8b",
    "messages": [
      {"role": "user", "content": "Return exactly: runtime-ok"}
    ],
    "temperature": 0,
    "max_tokens": 16
  }'

Затем проверьте сам сервис:

# llama.cpp
llama-server --version
llama-server --list-devices
curl http://127.0.0.1:8080/health
curl http://127.0.0.1:8080/v1/models

# Ollama
ollama --version
ollama ps
curl http://127.0.0.1:11434/api/ps
curl http://127.0.0.1:11434/v1/models

Если приложение зависит от формы ответа Ollama-native /api/chat, изменения базового URL недостаточно. Либо мигрируйте клиента на маршрут, совместимый с OpenAI, сначала, или добавляйте адаптер. Более широкое руководство по миграции с Ollama на vLLM обсуждает тот же принцип контракта-сначала для более крупного прыжка в рантайме.

Итоговый вердикт

Ollama — это лучший локальный бытовой прибор для моделей. Он предоставляет каталог моделей, воспроизводимые рецепты, разумное автоматическое размещение, удобные API и управление жизненным циклом, не требуя, чтобы каждый пользователь становился оператором вывода.

llama.cpp — это лучший инструмент точности. llama-server экспонирует достаточно плана выполнения, чтобы сделать ограниченную VRAM, длинный контекст, необычное оборудование, поддержку новых моделей и контролируемые эксперименты понятными, а не мистическими.

Для большинства людей правильная последовательность — не Ollama или llama.cpp навсегда. Начните с Ollama, узнайте, какие ограничения действительно важны, и перенесите затронутую рабочую нагрузку на прямой llama.cpp, когда вы можете назвать необходимый вам контрол. Это гораздо более сильное основание, чем гоняться за бенчмарком, измеренным с чужими значениями по умолчанию.

Ссылки

• Проект llama.cpp и поддерживаемые бэкенды
• Функции, флаги, эндпоинты и режим роутера llama-server
• FAQ Ollama: контекст, keep-alive, конкурентность и KV-кэш
• Справка по Modelfile Ollama
• Импорт моделей GGUF и Safetensors в Ollama
• Совместимость API Ollama с OpenAI
• Изменения в Ollama 0.30: GGUF, NVIDIA и Vulkan
• Как Ollama фиксирует и патчит llama.cpp
• Поддержка оборудования Ollama
• Значения по умолчанию длины контекста Ollama
• Релизы Ollama (GitHub)