Локальные LLM в разработке: а почему бы и да?

Меня зовут Антон Гращенков, и я занимаюсь развитием Java в Альфа-Банке. Программированием увлекаюсь ещё со школы: писал на множестве разных языков — от Pascal до TypeScript, мне это просто нравится. В статье я на примерах покажу, для каких задач я использую локальные модели. Да, существует много инструментов доступных в облаке, — тот же ChatGPT, Copilot или YandexGPT. Однако можно запустить такую модель и локально, и сделать это крайне просто. 

Ведь если хочется, то почему бы и да?

Вступление

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

Поэтому так же, как сейчас сложно найти человека в ИТ, который не умел бы пользоваться электронным таблицами, так и в скором времени не будет тех, кто не умеет эффективно использовать ИИ.

И если в целом с ИИ все понятно, то почему именно локальные модели? 

Плюсы локальной работы.

• Офлайн. Все локальные модели работают в офлайне и вам не нужен интернет, чтобы ими пользоваться. В дороге, в самолёте, в поезде и  на даче — везде, в любом месте, куда вы можете принести свой ноутбук, вы можете использовать ИИ.

• Приватность. Если вы используете локальную модельку, то никакие ваши данные ни на какие серверы не отправляются. Для кого-то это важно. 

• Политика безопасности компании. Этот пункт напрямую вытекает из предыдущего. Для работы с кодом этот самый код часто нужно отправлять в контексте запроса, и ваша компания может напрямую это запрещать.

• Это бесплатно. При использовании локальной модели, вам не нужно платить за токены при использовании API или оформлять платные подписки. Платим только за ноутбук и за электроэнергию, естественно.

Минусы локальной работы.

Естественно, локальные модели имеют ряд очень существенных ограничений.

• Ресурсы. Чем умнее модель, тем больше ресурсов она потребляет. Я подчеркну — они МНОГО «кушают». И чем умнее модель, тем больше она, соответственно, потребляет. Так что может потребоваться обновить компьютер «для работы» (да и видеокарту тоже).

• Скорость. Она не очень велика. Если вы у GPT что-то спросите, то ожидаете, что она вам ответит мгновенно. Ответа локальной модели придётся подождать какое-то время. Особенно на большом контексте и слабом железе.

• Точность. Мало того, что придётся ждать, так и точность ответа может быть невысокой, поэтому нужно всегда тщательно проверять, что она нам говорит. Локал-модельки не очень точные и могут изрядно фантазировать, что случается с большими сетями всё реже.

• Язык. Доступные модели, как правило, обучаются на англоязычных данных, так что общаться с ними лучше на английском. Можно использовать для запросов и русский язык, но точность может пострадать. Лучше, наверное, подучить английский язык.

Теперь к инструментарию.

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

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

И, конечно, нам, как разработчикам, важно, чтобы наш чатик работал в той IDE, которой мы пользуемся. Мне очень нравится Continue.dev: он доступен для IntelliJ IDEA и VS Code.

Давайте посмотрим как всё настроить и начать пользоваться.

Установка и настройка

Первое, что нам нужно сделать, — поставить Ollama. На Mac все достаточно просто:

brew install ollama

Для остальных операционных систем всё тоже весьма просто, например на Linux достаточно выполнить:

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

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

Начать можно, например, с этих четырёх:

• llama3 — модель общего назначения от Meta;

• mistral — модель общего назначения от Mistral AI;

• codellama — модель для работы с кодом от Meta;

• codegemma — модель для работы с кодом от Google.

Модели отличаются по количеству параметров. Чем их больше, тем модель умнее, но для локального запуска оптимальны модели с 7–8 миллиардами параметров, то есть 7–8 b.

Ставятся модели очень просто — командой:

ollama pull llama3

Здесь llama3 — название модели с сайта. 

Мы ставим сразу несколько моделей, потому что у разных моделей свои сильные стороны. Например, Mistral и llama3 хорошо работают просто с текстом (суммаризация, генерация текстов по заданному шаблону), а codellama или codegemma специализируются на работе с кодом.

Чтобы Ollama начала работать с нашими локальными клиентами, нужно запустить её в режиме сервера. Сделать это можно командой:

ollama serv 

А можно запустить её в режиме сервиса, что ещё лучше. На Mac запуск сервера в режиме сервиса происходит командой:

brew services start ollama

Так Ollama всегда будет запущена и готова к работе.

Последняя из настроек — настройка continue.dev, это плагин для нашей IDE. Хранятся они в ~/.continue/config.json Достаточно лишь изменить секцию models вот так:

"models": [
  {
    "title": "Ollama",
    "provider": "ollama",
    "model": "AUTODETECT"
  }
]

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

По настройкам всё — можно начинать пользоваться. 

Как использовать

Использовать Ollama можно несколькими способами.

1. Запустить модель можно при помощи команды ollama run llama3. При этом мы перейдём в режим интерактивного чата: пишем свой вопрос и получаем ответ.

2. Можно задавать вопросы в неинтерактивном режиме. Для этого передаём вопрос в качестве параметра ollama run llama3 ‘what is java?’.

3. Также можно писать собственных агентов, общаясь с Ollama при помощи REST API.

4. И, конечно же, можно использовать плагин в вашей любимой IDE. Он предоставляет окно чата, в которое можно вводить запросы.

Теперь посмотрим в каких сценариях мы можем использовать Ollama?

№1. Работа с утилитами, формат запросов которых я плохо помню

Например, я плохо помню формат запросов jq, и когда приходится с ним работать, я всё время читаю документацию. 

Допустим, я получил выгрузку с какими-то темами в JSON-файле и хочу отфильтровать темы, у которых лайков больше чем дизлайков.

[
  {
    "name": "Как установить LLM локально",
    "like": 2,
    "dislike": 1
  },
  {
    "name": "Пишем сортировку пузырьком 3 способами",
    "like": 1,
    "dislike": 5
  },
  {
    "name": "Как делегировать всю работу ИИ и зарабатывать миллион в час",
    "like": 9,
    "dislike": 2
  },
  {
    "name": "Можно ли программировать прямо в баше?",
    "like": 4,
    "dislike": 4
  },
  {
    "name": "Подключаем ChatGPT к vim",
    "like": 7,
    "dislike": 3
  },
  {
    "name": "Автоматичесоке преобразование JavaScript в Java",
    "like": 9,
    "dislike": 0
  }
]

Собственно, запускаем модель:

ollama run llama3

Формулируем запрос: 

I have an array of elements like { “name”: “My Name”, “like”: 2, “dislike”: 1}. Write a jq query to filter elements which have likes more than dislikes, show only element’s name.

На одни и те же промпты разные модели отвечают по-разному. Иногда можно получить что-то странное, иногда что-то хорошее. Но llama3, в принципе, справляется неплохо. Работа с с языковыми моделями — это не тоже самое, что программирование: для одного и того же «кода» результат может быть разный.

В итоге я получил вот такой ответ.

You can use the following `jq` command:

```bash
jq '.[] | select(.like > .dislike) | .name' your_array.json
```

Here's how it works:

- `.[]` iterates over each object in the array.
- `select(.like > .dislike)` filters out objects where likes are not greater than
dislikes. The `.` refers to the current object being processed.
- `.name` extracts and prints only the "name" value from the filtered objects.

Replace `your_array.json` with the actual path to your JSON file or input string.

И это корректная команда, можете убедиться сами!

№2. Работа с утилитами, для которых я плохо помню формат конфигурационных файлов

Это могут быть, например Dockerfile, Makefile или docker-compose.yaml. И вместо того, чтобы каждый раз гуглить синтаксис, можно использовать Ollama.

ollama run codegemma 'Write a docker-compose file. It should contain mongodb and minio. Map their ports to local machine. Add volumes to store data. Do not provide an explanation, just code.' > docker-compose.yaml

Здесь есть пара интересных моментов.

• Первый. Я запустил Ollama не в интерактивном режиме, а просто как команду. Это даёт нам возможность использовать Ollama для автоматизации рутины. Например, можно генерировать  тестовые данные или какие-то каркасы классов. 

• Второй. Это директива Do not provide an explanation, just code. Я прошу модель, чтобы она не генерировала пояснения к тому, что сделала. Так я могу перенаправить ответ в файл и получить готовый результат. Правда, иногда она всё же добавляет кавычки, чтобы оформить ответ в виде блока кода в Markdown.

И вот что я получил в результате.

version: "3.8"

services:
  mongodb:
    image: mongo:latest
    restart: unless-stopped
    ports:
      - 27017:27017
    volumes:
      - mongodb_data:/data/db

  minio:
    image: minio/minio:latest
    restart: unless-stopped
    ports:
      - 9000:9000
      - 9001:9001
    volumes:
      - minio_data:/data

volumes:
  mongodb_data:
  minio_data:

А теперь давайте посмотрим что-нибудь ближе к коду.

№3. Чтение кода

Я, конечно, пишу бэкенд, но нет-нет да и приходится посмотреть, что там происходит на фронтэнде. Если вы не очень хорошо знаете JavaScript/TypeScript, то читать его может быть достаточно непросто. И наш ассистент может помочь с этой проблемой.

На этот раз воспользуемся Visual Studio Code. Выделяем весь код, жмём Cmd-L и просим объяснить как работает код:

explain this code

Сам код при этом добавится в контекст запроса, и, немного подумав, модель выдаст свои пояснения.

Модель достаточно точно описывает что это код для разграничения доступа на основе белых списков и что для хранения пользователей используется MongoDB с библиотекой Mongoose.

Она описывает достаточно много подробностей, которых нет в коде. То есть они есть, но завуалированы. Мы, программисты, знаем, что  правильно названные переменные — половина смысла в нашей программе. И моделька понимает этот смысл. Понятное дело, что не так же хорошо, как мы, но примерно.

№4. Собственные ИИ агенты

Ну и, конечно, самое интересное — это использовать API для разработки собственных ИИ-агентов, которым можно поручить выполнение рутинных действий. С точки зрения программирования всё предельно просто: Ollama предоставляет REST API (по умолчанию на 11434 порту), в котором нам достаточно пары эндпоинтов. Давайте посмотрим, как это можно использовать.

Наверняка вы уже сталкивались с современными эмуляторами терминала, такими как Warp, у которых есть встроенный ИИ-помощник. Он преобразует запросы на естественном языке в команды, которые можно выполнить в терминале. Давайте сделаем так же, но для любого терминала и при помощи локальной LLM.

Для начала разберёмся с API. На GitHub есть подробная документация, так что разобраться не составит труда. Нам нужен метод api/generate, так как мы не собираемся общаться с моделью в режиме диалога, а хотим получить единственный ответ.

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

Write a program in go language. Generate only code, no explanations. Write a program to send http post request to local ollama server on port 11434. Endpoint is /api/generate. Payload is in json format and has fields model, prompt, system and stream. Get prompt from command line arguments, system and model from const. Set stream to false. Response is in json format and looks like

{
  "model": "llama3",
  "created_at": "2023-08-04T19:22:45.499127Z",
  "response": "",
  "done": true,
  "context": [1, 2, 3],
  "total_duration": 10706818083,
  "load_duration": 6338219291,
  "prompt_eval_count": 26,
  "prompt_eval_duration": 130079000,
  "eval_count": 259,
  "eval_duration": 4232710000
}.

Create and use struct types for the payload and response. Unmarshall the response and print "response" field.

В результате получим заготовку для нашего агента. Она, конечно, не идеальна, но компилируется, работоспособна, решает проблему «чистого листа», и её можно доработать так, как нам хочется.

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"time"
)

type Payload struct {
	Model  string `json:"model"`
	Prompt string `json:"prompt"`
	System string `json:"system"`
	Stream bool   `json:"stream"`
}

type Response struct {
	Model              string    `json:"model"`
	CreatedAt          time.Time `json:"created_at"`
	Response           string    `json:"response"`
	Done               bool      `json:"done"`
	Context            []int     `json:"context"`
	TotalDuration      int64     `json:"total_duration"`
	LoadDuration       int64     `json:"load_duration"`
	PromptEvalCount    int       `json:"prompt_eval_count"`
	PromptEvalDuration int64     `json:"prompt_eval_duration"`
	EvalCount          int       `json:"eval_count"`
	EvalDuration       int64     `json:"eval_duration"`
}

func main() {
	// Get prompt from command line arguments
	prompt := os.Args[1]

	// Set system and model from const
	system := "llama"
	model := "llama3"

	// Set stream to false
	stream := false

	// Create payload
	payload := Payload{
		Model:  model,
		Prompt: prompt,
		System: system,
		Stream: stream,
	}

	// Marshal payload to JSON
	jsonPayload, err := json.Marshal(payload)
	if err != nil {
		log.Fatal(err)
	}

	// Send HTTP POST request to local ollama server on port 11434
	resp, err := http.Post("http://localhost:11434/api/generate", "application/json", bytes.NewBuffer(jsonPayload))
	if err != nil {
		log.Fatal(err)
	}

	// Read response body
	body, err := io.ReadAll(resp.Body)
	println(string(body))
	if err != nil {
		log.Fatal(err)
	}

	// Unmarshal JSON response
	var response Response
	err = json.Unmarshal(body, &response)
	if err != nil {
		log.Fatal(err)
	}

	// Print "response" field
	fmt.Println(response.Response)
}

Приступим к доработкам. 

Первое, что нужно сделать, — поменять system, то есть указания модели, как она должна себя вести. Наша модель должна знать, что мы хотим от неё получить и в каком виде. В нашем случае роль модели — системный администратор, который пишет команды для Bash, выполняющие то, что мне нужно.

И, конечно, нужны исключительно команды, без пояснений. Получается примерно так.

You are a system administrator. Write bash commands that do what I ask. Generate the commands and only the commands, no explanations or formatting. I want to copy your response directly to a terminal emulator and execute it.

Несмотря на просьбу не форматировать ответ, модель иногда возвращает ответы, окружённые кавычками, форматируя их в Markdown. Поэтому добавим небольшую обработку, которая удаляет эти кавычки из ответа.

Ну и, конечно, проведём небольшой рефакторинг, больше для собственного удовольствия. Я же говорил, что люблю писать код?

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/exec"
	"strings"
)

type Config struct {
	model  string
	system string
	url    string
}

func config() Config {
	return Config{
		model:  "codellama",
		system: "You are a system administrator. Write bash commands that do what I ask. Generate the commands and only the commands, no explanations or formatting. I want to copy your response direct to a terminal emulator and execute it.",
		url:    "http://localhost:11434/api/generate",
	}
}

type Response struct {
	Model              string `json:"model"`
	CreatedAt          string `json:"created_at"`
	Response           string `json:"response"`
	Done               bool   `json:"done"`
	Context            []int  `json:"context"`
	TotalDuration      int64  `json:"total_duration"`
	LoadDuration       int64  `json:"load_duration"`
	PromptEvalCount    int    `json:"prompt_eval_count"`
	PromptEvalDuration int64  `json:"prompt_eval_duration"`
	EvalCount          int    `json:"eval_count"`
	EvalDuration       int64  `json:"eval_duration"`
}

type Payload struct {
	Model  string `json:"model"`
	Prompt string `json:"prompt"`
	System string `json:"system"`
	Stream bool   `json:"stream"`
}

func main() {
	// Get the prompt from command line arguments
	prompt := os.Args[1]

	resp, err := sendAiRequest(prompt)
	if err != nil {
		fmt.Println("Can not generate prompt: ", err)
	}
	cmd := getCommand(resp.Response)
	fmt.Print(cmd)
}

func sendAiRequest(prompt string) (*Response, error) {
	cfg := config()

	payload := Payload{
		Model:  cfg.model,
		Prompt: prompt,
		System: cfg.system,
		Stream: false,
	}

	// Marshal the payload to JSON
	jsonPayload, err := json.Marshal(payload)
	if err != nil {
		fmt.Println("Error marshaling payload: ", err)
		return nil, err
	}

	// Send HTTP POST request to local ollama server on port 11434
	client := &http.Client{}
	req, err := http.NewRequest("POST", cfg.url, bytes.NewBuffer(jsonPayload))
	if err != nil {
		fmt.Println("Error creating request: ", err)
		return nil, err
	}
	req.Header.Add("Content-Type", "application/json")

	res, err := client.Do(req)
	if err != nil {
		fmt.Println("Error sending request: ", err)
		return nil, err
	}
	defer res.Body.Close()

	// Read response body
	body, err := io.ReadAll(res.Body)
	if err != nil {
		fmt.Println("Error reading response: ", err)
		return nil, err
	}

	// Unmarshal JSON response
	var response Response
	err = json.Unmarshal(body, &response)
	if err != nil {
		fmt.Println("Error unmarshaling response: ", err)
		return nil, err
	}

	return &response, nil
}

func getCommand(raw string) string {
	cmd := ""
	scanner := bufio.NewScanner(strings.NewReader(raw))
	for scanner.Scan() {
		line := scanner.Text()
		if strings.HasPrefix(line, "```") {
			continue // skip lines starting with ```
		}
		cmd += line + " "
	}
	cmd = strings.TrimSpace(cmd)
	if strings.HasPrefix(cmd, "`") && strings.HasSuffix(cmd, "`") {
		cmd = strings.TrimPrefix(cmd, "`")
		cmd = strings.TrimSuffix(cmd, "`")
	}
	return cmd
}

Скомпилируем получившееся при помощи go build и проверим, работает ли наш агент (я назвал его cli-ai).

Работает! 

Осталось только настроить шелл. Я использую zsh, так что добавим функцию для вызова нашего агента и забиндю её на Ctrl-a, i добавив в ~/.zshrc следующий код.

function _ai() {
  prompt="'$BUFFER'"
  zle -R "Thinking about $prompt..."
  cmd=$(/Users/bidzo/develop/bidzo/go/ai-cli/cli-ai $prompt)
  BUFFER="$cmd"
  zle end-of-line
}
zle -N _ai
bindkey "^ai" _ai

Перезапускаем zsh и смотрим, как в шеле просыпается искусственный интеллект.

Как видите, написать своего простого агента не составляет труда, причем на любом языке, который вам нравится. Такой подход можно использовать для автоматизации любой рутины, главное — чётко представлять, какой результат вы хотите получить.

Итого

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

Однако они могут помочь быстро создать каркас приложения и нужных классов, а зачастую подкидывают интересные идеи, которые можно развивать. И это крайне полезно, особенно если у вас нет доступа к интернету ;). Не зря copilot называется copilot, а не автопилот. Эта штука помогает нам писать код, но пока не пишет за нас. 

Всё равно программисту нужно:

• Предельно точно и чётко сформулировать задачу. Без этого результата точно не будет. ИИ не человек, вместо того чтобы уточнить непонятный момент, он его додумает, и, скорее всего, не так, как нам хотелось бы.

• Проверить результат.

• Доработать полученный код напильником, чтобы он запускался. Потому что, сюрприз, сетка ничего не понимает в программировании — она знает, как составить слова, чтобы это было похоже на программу. Поэтому без программиста всё равно никак.