Notebook в официальном WebUI llama.cpp: почему text-generation-webui больше не нужен

Зачем нужен ещё один интерфейс для локальных LLM?

Если вы работаете с локальными языковыми моделями, то наверняка сталкивались с text-generation-webui (он же Oobabooga). Удобный интерфейс, куча настроек, поддержка разных бэкендов. Но есть одна проблема - он живёт своей жизнью. Обновления llama.cpp появляются там через недели, а иногда и месяцы. А что делать, если вам нужны функции из свежего коммита прямо сейчас?

Вот здесь и появляется официальный WebUI от разработчиков llama.cpp. Не тот, что вы видели год назад с парой кнопок и полем ввода. Речь о полноценном Notebook режиме, который появился в конце 2024 года и активно развивается до сегодняшнего дня (04.02.2026).

Что происходит с text-generation-webui в 2026 году

Oobabooga - прекрасный проект, но у него есть архитектурные ограничения. Он должен поддерживать десяток разных бэкендов (transformers, exllama, llama.cpp и т.д.), и каждый из них обновляется в своём темпе. Когда в llama.cpp появляется новая функция (скажем, поддержка новой квантования или оптимизация для конкретного GPU), её интеграция в text-generation-webui занимает время.

А теперь представьте: вы читаете коммит в репозитории llama.cpp, где добавили поддержку flash attention для вашей видеокарты. Скорость увеличивается в 1.5 раза! Но в text-generation-webui этой функции нет, и неизвестно, когда появится. Что делать? Ждать? Нет, переходить на официальный WebUI.

1 Установка: проще, чем кажется

Многие думают, что официальный WebUI - это что-то сложное, требующее сборки из исходников. На самом деле всё проще:

# Клонируем репозиторий
cd ~
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Собираем с поддержкой всех фич
make -j$(nproc)

# Запускаем WebUI с Notebook режимом
./server -m models/mistral-7b-instruct-v0.3.Q4_K_M.gguf --port 8080 --n-gpu-layers 35

Открываем браузер на http://localhost:8080 и видим две вкладки: Chat и Notebook. Всё.

2 Первый запуск Notebook: что там внутри

Открываете вкладку Notebook и видите интерфейс, похожий на Jupyter. Слева - ячейки с кодом, справа - вывод. Но это не просто текстовый редактор. Это полноценный Python-интерпретатор со встроенными биндингами llama.cpp.

Вот пример, который невозможно сделать в text-generation-webui без танцев с бубном:

# Загружаем модель напрямую через llama.cpp
from llama_cpp import Llama

# Используем самые новые параметры из февральского обновления 2026
llm = Llama(
    model_path="models/mistral-7b-instruct-v0.3.Q4_K_M.gguf",
    n_gpu_layers=35,
    n_ctx=8192,
    flash_attn=True,  # Эта опция появилась в январе 2026
    rope_freq_base=10000,
    rope_freq_scale=1.0,
    verbose=True
)

# Генерация с полным контролем над параметрами
output = llm(
    "Расскажи мне о квантовании в llama.cpp",
    max_tokens=500,
    temperature=0.7,
    top_p=0.95,
    repeat_penalty=1.1,
    frequency_penalty=0.0,
    presence_penalty=0.0,
    stop=["\n\n", "Human:", "Assistant:"]
)

print(output["choices"][0]["text"])

Видите параметр flash_attn=True? В text-generation-webui его до сих пор нет, хотя в llama.cpp он появился месяц назад. Вот вам и главное преимущество.

Пять вещей, которые вы не сможете сделать в text-generation-webui

3 Реальный пример: создаём AI-тьютор за 10 минут

Допустим, вы хотите создать что-то вроде персонализированного AI-тьютора с Personal-Guru, но без лишних зависимостей. В text-generation-webui вам пришлось бы писать расширение на Python, компилировать его, молиться, чтобы всё заработало. В Notebook режиме всё проще:

# Загружаем документы для обучения (как в локальных альтернативах NotebookLM)
import PyPDF2
import json

class AITutor:
    def __init__(self, model_path):
        self.llm = Llama(model_path=model_path, n_gpu_layers=35)
        self.knowledge_base = []
    
    def add_document(self, filepath):
        """Парсим PDF и добавляем в базу знаний"""
        with open(filepath, 'rb') as file:
            pdf_reader = PyPDF2.PdfReader(file)
            for page_num in range(len(pdf_reader.pages)):
                text = pdf_reader.pages[page_num].extract_text()
                self.knowledge_base.append({
                    'page': page_num + 1,
                    'text': text[:1000]  # первые 1000 символов
                })
    
    def ask(self, question):
        """Отвечаем на вопрос на основе документов"""
        context = "\n".join([item['text'] for item in self.knowledge_base[:5]])
        prompt = f"""Используй следующий контекст:
{context}

Вопрос: {question}

Ответ:"""
        
        response = self.llm(prompt, max_tokens=300)
        return response["choices"][0]["text"]

# Использование
tutor = AITutor("models/mistral-7b-instruct-v0.3.Q4_K_M.gguf")
tutor.add_document("physics_textbook.pdf")
answer = tutor.ask("Объясни второй закон Ньютона простыми словами")
print(answer)

Этот код работает прямо в браузере. Никаких установок дополнительных пакетов (кроме PyPDF2, но его можно добавить через pip в терминале). Вы сразу видите результат, можете его редактировать, экспериментировать.

Подводные камни, о которых молчат

Конечно, не всё так радужно. У Notebook режима есть свои особенности, которые могут раздражать:

• Нет сохранения сессий: закрыли браузер - потеряли весь код. Решение: копировать важные скрипты в отдельные файлы.
• Ограниченный autocomplete: не ждите IntelliSense уровня VS Code. Это базовый редактор кода.
• Меньше готовых шаблонов: в text-generation-webui есть Character Cards, шаблоны промптов и прочее. Здесь всё с нуля.
• Требует знания Python: если вы не программист, интерфейс чата будет удобнее.

Но вот что интересно: многие из этих ограничений исчезают, если посмотреть на это с другой стороны. Нет шаблонов? Зато нет и ограничений на создание своих. Нет сохранения сессий? Зато код всегда перед глазами, не спрятан в конфигах.

4 Интеграция с другими инструментами: где это полезно

Если вы разрабатываете мобильное приложение с локальным ИИ на llama.cpp, то Notebook режим становится бесценным инструментом для прототипирования. Вы тестируете промпты, параметры генерации, логику работы - всё в одном месте, без переключения между IDE и интерфейсом LLM.

Пример интеграции с внешним API:

# Тестируем промпты для мобильного приложения
import requests

# Подготавливаем тестовые данные
test_prompts = [
    "Напиши короткое приветствие для пользователя",
    "Объясни сложную тему простыми словами",
    "Сгенерируй идею для проекта"
]

for prompt in test_prompts:
    # Используем точно те же параметры, что будут в приложении
    response = llm.create_completion(
        prompt,
        max_tokens=150,
        temperature=0.3,  # Низкая температура для предсказуемости
        top_p=0.9,
        frequency_penalty=0.5
    )
    
    # Проверяем длину (важно для мобильных устройств)
    if len(response["choices"][0]["text"]) > 100:
        print(f"Промпт '{prompt[:50]}...' даёт слишком длинный ответ")
    else:
        print(f"OK: {response['choices'][0]['text'][:50]}...")

Когда всё-таки стоит использовать text-generation-webui

Я не говорю, что text-generation-webui нужно удалить. Есть ситуации, где он всё ещё лучше:

• Вы не программист: интерфейс чата с кнопками и слайдерами проще для новичка.
• Нужны готовые расширения: поддержка TTS, Stable Diffusion интеграция и прочее.
• Работа с Character Cards: если вы создаёте AI-персонажей для ролевых игр.
• Частая смена моделей: интерфейс загрузки моделей в Oobabooga более удобен.

Но если вы техник, разработчик или исследователь, который хочет максимального контроля и скорости доступа к новым функциям - Notebook режим в официальном WebUI ваш выбор.

Настройка для максимальной производительности

По умолчанию Notebook работает неплохо, но есть несколько настроек, которые дадут прирост скорости:

# Запуск с максимальной оптимизацией
./server -m models/mistral-7b-instruct-v0.3.Q4_K_M.gguf \
  --port 8080 \
  --n-gpu-layers 999 \  # Все слои на GPU
  --flash-attn \  # Flash Attention (если поддерживается)
  --n-parallel 4 \  # Параллельная обработка
  --n-batch 512 \  # Размер батча
  --ctx-size 8192 \  # Контекстное окно
  --mlock \  # Фиксируем модель в памяти
  --no-mmap  # Отключаем mmap для стабильности

Особое внимание обратите на флаг --flash-attn. В последних версиях llama.cpp (на начало 2026 года) его поддержка значительно улучшилась, и на некоторых видеокартах он даёт до 40% прироста скорости.

Что будет дальше: прогноз на 2026-2027

Судя по активности в репозитории llama.cpp, Notebook режим будет развиваться в сторону:

1. Более умного автодополнения: сейчас оно базовое, но уже есть PR с интеграцией Tree-sitter.
2. Поддержки плагинов: возможность устанавливать расширения прямо из интерфейса.
3. Визуализации работы модели: графики внимания, активации нейронов и прочая диагностика.
4. Интеграции с Jupyter: возможность экспортировать блокноки в стандартный формат .ipynb.

Если вы уже сегодня начнёте использовать Notebook режим, то к середине 2026 года будете чувствовать себя как рыба в воде, когда все эти фичи появятся.

FAQ: ответы на частые вопросы

Можно ли использовать Notebook режим для NSFW-контента?

Да, абсолютно. Как и в случае с NSFW-чатом с картинками, всё работает локально, никаких ограничений нет. Вы контролируете и модель, и промпты.

Как импортировать код из Notebook в свой проект?

Просто копируете рабочие функции из ячеек в файлы .py. Биндинги llama-cpp-python одинаково работают и в Notebook, и в обычном Python скрипте.

Поддерживает ли Notebook режим многопользовательскую работу?

Нет, это инструмент для одного пользователя. Для многопользовательских сценариев лучше использовать фронтенды для OpenAI-совместимого API.

Можно ли использовать разные модели в разных ячейках?

Технически да, но память будет ограничена. Лучше работать с одной моделью за сессию.

Последний совет перед началом

Не пытайтесь перенести все свои workflow из text-generation-webui в Notebook за один день. Начните с малого: возьмите одну задачу, которую сложно решить в Oobabooga (например, пакетную обработку документов), и реализуйте её в Notebook. Потом ещё одну. Через неделю вы обнаружите, что 80% работы делаете уже там.

И помните: главное преимущество Notebook режима - не в интерфейсе, а в скорости доступа к инновациям. Когда в следующий раз увидите крутую фичу в changelog llama.cpp, вы сможете использовать её сразу, а не через месяц. В мире локальных LLM, где всё меняется каждую неделю, это дорогого стоит.