Хай-тек у двох рядках: як просто почати програмувати LLM з Ollama та chuk-llm

Хай-тек у дві рядки: як розмова з комп’ютером стала простішою за чашку кави

Привіт, друзі! З вами Ліла Харт, і сьогодні я відкрию вам дивовижну історію, яка почалася зі звичайного виклику. Мій колега, справжній гуру коду, сказав: “Ліло, а ти впевнена, що зможеш навчити когось програмувати, спілкуючись з великими мовними моделями, всього за два рядки коду?” Я посміхнулася, згадала свої експерименти й відповіла: “Тримай каву, зараз покажу!”

І знаєте що? Це не були порожні слова. Те, що ще кілька років тому здавалося фантастикою – можливість буквально “поговорити” з машиною, змусити її генерувати тексти, відповідати на запитання, писати код – сьогодні доступне як ніколи. Це як відчинити двері до майбутнього, яке вже настало, і виявити, що ключ до нього – це всього лише кілька простих команд.

Ми живемо у захопливий час, коли штучний інтелект, зокрема великі мовні моделі (LLM), перестають бути чимось ефемерним і стають потужними інструментами, які можна використовувати у повсякденному житті та професійній діяльності. Але часто, коли ми чуємо про LLM, виникає думка: “Ого, це ж для геніїв програмування!” Або: “Напевне, треба витратити тижні, щоб налаштувати все обладнання та написати складний код”. Що ж, сьогодні ми розвіємо ці міфи.

Готові піти цим шляхом зі мною? Я розповім вам, як швидко, легко і, головне, з задоволенням зануритися у світ програмування великих мовних моделей. Це буде подорож, сповнена відкриттів, простих аналогій та, звісно, щирого захоплення від того, наскільки технології можуть бути людяними. Тож, зручно вмощуйтеся, наливайте собі чогось смачненького, і давайте розпочнемо нашу пригоду!

З чого почати: Зустрічайте вашого нового цифрового друга

Уявіть собі: ви хочете навчити свого нового розумного помічника, скажімо, робота-пилососа, як найкраще прибирати вашу квартиру. Вам не потрібно розбирати його на гвинтики чи читати інструкцію на 500 сторінок, правда? Ви просто кажете: “Прибери під диваном, я там щось загубив”. І він розуміє.

Великі мовні моделі – це теж такі розумні помічники, тільки трішки складніші. Вони вміють не тільки прибирати, а й писати вірші, розмовляти різними мовами, пояснювати складні речі простими словами. Але щоб з ними “поговорити” напряму, потрібен певний інструмент. І тут на сцену виходить Ollama.

Що таке Ollama? Думайте про нього як про надзвичайно зручний “пульт керування” для великих мовних моделей. Він дозволяє без зайвого клопоту завантажувати ці моделі на ваш власний комп’ютер (так, прямо на ваш ноутбук чи ПК!) і запускати їх. Це означає, що ви можете експериментувати, вчитися і навіть створювати свої перші проєкти, не переймаючись дорогими серверами чи складними налаштуваннями хмарних сервісів.

Як це зробити? Все дуже просто. Заходите на сайт ollama.com [https://ollama.com/], обираєте версію для вашої операційної системи (Mac, Linux чи Windows) і встановлюєте. Це як завантажити нову гру на комп’ютер – кілька кліків, і готово.

Після встановлення відкриваєте термінал (це така чорно-біла консоль, де програмісти часто “говорять” з комп’ютером) і набираєте команду ollama. Якщо все гаразд, ви побачите вітання від системи. Це означає, що ваш “пульт” готовий до роботи!

Тепер найцікавіше: завантаження самої мовної моделі. Ollama має справжню “бібліотеку” моделей, де кожна – це окремий “розум”, навчений на величезній кількості інформації. Для нашого експерименту ми візьмемо одну з моделей, на ім’я Granite 3.3. Щоб її завантажити, набираємо команду:

ollama pull granite:3.3

Ця команда скаже Ollama: “Гей, друже, завантаж мені, будь ласка, модель Granite 3.3”. Це може зайняти деякий час, адже моделі бувають досить “важкими”, як великий мультимедійний файл. Але зачекайте – воно того варте!

Коли модель завантажилася, ви можете почати розмову з нею. Як? Так само просто:

ollama run granite:3.3 "Привіт, як справи?"

І вуаля! Ви побачите відповідь від моделі: “Привіт! Як я можу допомогти?” Це вже не просто програмування, це початок діалогу, де ви вчитеся керувати потужною системою. Це як вперше завести автомобіль – трохи незвично, та як приємно відчувати контроль!

Цікаво знати: Чи знали ви, що моделі, подібні до Granite 3.3, навчаються на даних, які можна порівняти з тисячами бібліотек, зібраних разом? Це як величезна світова енциклопедія, що вміщується у вашому комп’ютері.

Код, що літає: Два рядки – і ви програмуєте LLM

Окей, ми навчилися запускати моделі локально. Це вже круто! Але пам’ятаєте, я обіцяла навчити вас програмувати LLM всього за два рядки коду? Ось тут починається справжня магія.

Щоб зробити процес програмування ще простішим, існує спеціальна бібліотека (уявіть собі як зручний інструмент, який ви додаєте до свого робочого набору). Цю бібліотеку, яку ми умовно назвемо chuk-llm, розробили так, щоб вона була максимально зрозумілою та ефективною.

Перш ніж ми почнемо писати код, нам потрібно встановити цю бібліотеку. Для цього нам знадобиться ще один чудовий інструмент – менеджер пакетів UV. Він допомагає встановлювати та керувати різними програмними модулями. Заходимо на astral.sh [https://astral.sh/], знаходимо інструкції з встановлення – все максимально просто. Якщо ви користуєтеся Mac, то команда буде така:

brew install uv

Після встановлення UV, ми можемо перевірити, чи все працює належним чином, виконавши команду:

uvx chuk-llm test ollama

Якщо ви побачите повідомлення про успішне проходження тесту, це означає, що наш “зв’язковий” між вашим кодом та моделлю Ollama готовий до роботи.

Тепер, коли все налаштовано, ми можемо перейти до нашого Python-проєкту. Для цього в терміналі набираємо:

uv init

Ця команда створить базову структуру нового Python- проєкту. Відкриваємо створену папку у вашому улюбленому редакторі коду (наприклад, Visual Studio Code). Ви побачите файл main.py. Щоб перевірити, чи проєкт взагалі запускається, виконайте:

uv run main.py

Ви повинні побачити простий вивід: “Hello from chuk LLM demo”. Це наш перший “Hello, World!” у світі LLM.

Далі, нам потрібно додати бібліотеку chuk-llm до нашого проєкту. Робимо це за допомогою команди:

uv add chuk-llm

Тепер ця бібліотека доступна для використання у нашому проєкті. Повертаємося до файлу main.py, видаляємо попередній “Hello, World!” і пишемо наші два заповітні рядки коду:

python from chuk_llm import ask_ollama_granite print(ask_ollama_granite("Хто така Ада Лавлейс?"))

Ось і все! Перший рядок імпортує потрібну функцію, а другий – робить запит до моделі Granite 3.3, питаючи про Аду Лавлейс. Запускаємо проєкт командою uv run main.py.

Минуло кілька секунд, і модель видає відповідь про Аду Лавлейс. Це було настільки просто, що спочатку не віриться! Але саме так, за два рядки коду, ми вже можемо спілкуватися з великою мовною моделлю.

Гумористичне застереження: Не робіть, як я одного разу, коли намагався запустити цей код за три рядки, додавши зайвий import. Повірте, два – це саме та магічна цифра!

Чарівність потоку: коли відповідь народжується на очах

Чи помітили ви, як модель відповідала? Відповідь з’являлася поступово, рядок за рядком, ніби хтось писав текст прямо на екрані. Це називається “стрімінговий” ефект, і він надзвичайно важливий, коли ми працюємо з LLM.

Уявіть, що ви чекаєте на відповідь від людини. Якщо вона мовчить хвилину, а потім видає одразу повну розповідь, це може бути трохи дивно. А от коли людина говорить, формулюючи думку по ходу, це виглядає більш природно, чи не так?

LLM працюють за принципом “передбачення наступного токена”. Тобто, вони генерують відповідь, поширюючи її на виявлені слова та частини слів. Тому “стрімінг” дозволяє нам бачити, як ця думка народжується.

Але що, якби ви хотіли запрограмувати цей стрімінговий ефект, а не просто отримати готову відповідь? Тут нам знадобиться трохи магії асинхронного програмування та бібліотека asyncio, яка вже інтегрована з chuk-llm.

Тепер наш код матиме такий вигляд:

“`python
import asyncio
from chuk_llm import stream_ollama_granite

async def stream_example():
async for chunk in stream_ollama_granite(“Хто така Ада Лавлейс?”):
print(chunk, end=””, flush=True)

if name == “main“:
asyncio.run(stream_example())
“`

Подивіться на ці зміни:

1. Ми імпортуємо asyncio та функцію stream_ollama_granite.
2. Створюємо асинхронну функцію stream_example.
3. Використовуємо async for, щоб перебирати кожен “шматок” тексту (chunk), який генерує модель.
4. print(chunk, end="", flush=True) виводить кожен шматок тексту без нового рядка і одразу ж показує його на екрані.
5. asyncio.run() запускає нашу асинхронну функцію.

Запускаємо цей код, і ви побачите, як відповідь на запитання про Аду Лавлейс з’являється перед вами, слово за словом. Це приклад того, як глибокі технічні концепції можуть бути елегантно реалізовані, роблячи взаємодію з технологіями більш інтуїтивною.

Цікаво знати: Асинхронне програмування схоже на те, як офіціант одночасно приймає замовлення, приносить страви та спілкується з іншими відвідувачами, не зупиняючись надовго на комусь одному. Це дозволяє програмі “робити багато справ” одночасно, не блокуючи себе.

Характер для машини: як надати LLM особистості

Уявіть, що ви телефонуєте до служби підтримки. В одного оператора ви завжди отримуєте суху, формальну відповідь, а в іншого – доброзичливий, співчутливий тон. До якого з них ви б хотіли звернутися з вашою проблемою? Звісно, до другого!

Великі мовні моделі теж можуть мати “характер”. Це досягається за допомогою системних промптів (system prompts). Уявіть, що це як інструкція на початку розмови, яка каже моделі: “Ти – це хтось. Поводься ось так”.

Найцікавіше, що ці системні промпти мають вищий пріоритет. Це означає, що модель буде намагатися дотримуватися заданої персонажі, навіть якщо ви попросите її про щось інше. Це особливо корисно, коли модель повинна запам’ятовувати контекст розмови, адже вона знає, в якій ролі їй потрібно відповідати.

Давайте спробуємо надати нашій моделі Granite 3.3 індійську особистість. Додамо ще один рядок до нашого коду, але цього разу скористаємося функцією stream_ollama_granite та додамо параметр system_prompt:

“`python
import asyncio
from chuk_llm import stream_ollama_granite

async def pirate_persona_example():
persona = “Ти – пірат на ім’я Джоллі Роджер. Завжди говори піратським жаргоном.”
async for chunk in stream_ollama_granite(“Хто така Ада Лавлейс?”, system_prompt=persona):
print(chunk, end=””, flush=True)

if name == “main“:
asyncio.run(pirate_persona_example())
“`

Тепер, коли ми запитаємо про Аду Лавлейс, наша модель відповість як справжній морський вовк! Спробуйте запустити цей код, і побачите, як “Ада Лавлейс” перетворюється на “леді А. Лавлейс, корабельну навігаторку”. Це відкриває двері до створення персоналізованих чат-ботів, віртуальних асистентів та навіть персонажів для ігор.

Лайфхак: Системні промпти можна використовувати не тільки для надання особистості, але й для визначення формату відповіді (наприклад, “дай відповідь тільки списком”, “відповідай як експерт з історії”).

Бесіда за кавою: LLM пам’ятає все

А що, якби ми хотіли не просто поставити одне запитання, а поговорити з моделлю, як з давнім другом? Щоб вона пам’ятала, хто ми, що ми робимо, і відповідала з урахуванням попередніх розмов? Це називається багатоходові розмови (multi-turn conversations).

chuk-llm робить це надзвичайно просто. Для цього використовується зручний інтерфейс conversation.

“`python
import asyncio
from chuk_llm import conversation

async def chat_example():
async with conversation(provider=”ollama”, model=”granite:3.3″) as chat:
# Перший хід
question1 = “Мене звати Кріс, і я вивчаю Python.”
print(f”Ви: {question1}”)
response1 = await chat.ask(question1)
print(f”Модель: {response1}”)

 # Другий хід, як продовження першого question2 = "Що саме я вивчаю?" print(f"Ви: {question2}") response2 = await chat.ask(question2) print(f"Модель: {response2}") 

if name == “main“:
asyncio.run(chat_example())
“`

У цьому коді:

1. Ми імпортуємо conversation.
2. Запускаємо асинхронний менеджер контексту conversation, вказуючи провайдера (Ollama) та модель (Granite 3.3).
3. Використовуємо chat.ask() для відправки запитань.
4. Найголовніше: модель пам’ятає, що Кріс вивчає Python, і відповідає на друге запитання, враховуючи попередній контекст.

Дивовижно, чи не так? Не потрібно самому зберігати історію повідомлень, передавати її назад моделі – conversation робить це за нас. Це як справжня розмова, де співрозмовник згадує, про що ви говорили останнім часом.

Цікаво знати: Цей механізм пам’яті дозволяє створювати більш складні додатки, наприклад, віртуальних викладачів, які слідкують за прогресом учня, або чат-ботів для підтримки клієнтів, які розуміють історію взаємодії.

Під капотом: як це виглядає “на низькому рівні”

Ми побачили, як просто можна програмувати LLM за допомогою chuk-llm. Але що відбувається “під капотом”? Як виглядає взаємодія з моделлю, якщо не використовувати ці зручні “прискорювачі”?

Виявляється, що багато LLM-бібліотек мають схожий інтерфейс, який базується на списку повідомлень (messages array). Кожне повідомлення має роль (system, user, assistant) та контент (текст повідомлення).

Ось як це могло б виглядати, якби ми працювали з нижчим рівнем API:

“`python
import asyncio
from chuk_llm import get_client

async def low_level_example():
client = get_client(provider=”ollama”, model=”granite:3.3″)

messages = [ {"role": "system", "content": "Ти - пірат на ім'я Джоллі Роджер. Завжди говори піратським жаргоном."}, {"role": "user", "content": "Хто така Ада Лавлейс?"} ] completion = await client.create_completion(messages=messages) print(completion["response"]) # Припустимо, відповідь знаходиться в ключі 'response' 

if name == “main“:
asyncio.run(low_level_example())
“`

Тут ми:

1. Використовуємо get_client для отримання клієнта для конкретної моделі.
2. Формуємо список messages, де вказуємо системну інструкцію та запитання користувача.
3. Викликаємо client.create_completion(), передаючи цей список.

Це дає нам повний контроль, але вимагає більше коду та розуміння формату даних. chuk-llm бере на себе всю цю складність, генеруючи потрібні функції “на льоту”, що робить процес набагато зручнішим.

Порівняння: Це як порівняти приготування борщу з нуля, коли ти сам обираєш кожен інгредієнт, вариш бульйон, ріжеш овочі, з тим, щоб просто розігріти готову порцію з ресторану. Обидва варіанти дають борщ, але процес різний.

Висновок: ваш крок у майбутнє – це вже сьогодні!

Отже, друзі, ми пройшли шлях від простих команд до програмування великих мовних моделей. Ми побачили, як легко встановити Ollama, завантажити модель, написати всього два рядки коду, аби почати спілкуватися з LLM. Ми навчилися надавати моделі особистості, вести з нею тривалі діалоги та навіть зазирнули “під капот” цих дивовижних технологій.

Це захопливо, чи не так? Те, що колись здавалося складним і невловимим, тепер стало доступним майже кожному. Це відкриває безмежні можливості для навчання, творчості та створення нових, інноваційних проєктів.

Що далі?

1. Спробуйте самі! Встановіть Ollama, завантажте модель і запустіть ті приклади коду, які ми сьогодні розглядали. Експериментуйте з різними запитаннями, створіть власні системні промпти.
2. Розширюйте знання. Подивіться, які ще моделі доступні в бібліотеці Ollama. Спробуйте написати невелику програму, яка, наприклад, генерує короткі історії або перекладає тексти.
3. Досліджуйте агентів. В одному з наступних відео ми обов’язково торкнемося теми “агентів” – це наступний крок у розвитку LLM, де моделі можуть використовувати інструменти для виконання складніших завдань.

Пам’ятайте, що головне в технологіях – це не складність, а те, як вони допомагають нам розкривати наш потенціал. Світ LLM тільки починається, і ви вже маєте інструменти, щоб бути його частиною.

Підсумовуючи все вище сказане, сучасні інструменти, такі як Ollama та бібліотеки на кшталт chuk-llm, демократизують доступ до потужних великих мовних моделей. Те, що раніше вимагало глибоких знань та дорогого обладнання, тепер доступне кожному, хто має комп’ютер та бажання вчитися. Ці технології – це не просто цифри та алгоритми, це інструмент для розширення наших можливостей, для творчості та для створення майбутнього, в якому машини стають нашими партнерами, а не просто складними машинами.

Тож, вперед, друзі! Не бійтеся експериментувати, творіть, і нехай ваш шлях у світ великих мовних моделей буде таким же захопливим, як наша сьогоднішня розмова! До зустрічі!