Zbuduj lokalnego czata AI w Pythonie - Mercury + Bielik LLM krok po kroku

Niedawo opublikowaliśmy wersję 3 naszej biblioteki Mercury która umożliwia budowanie aplikacji webowych bezpośrednio z notatnika Pythonowego. Nowa wersja oferuje widgety pozwalające na łatwe budowanie aplikacji typu chat. To pozwala na tworzenie różnorodnych aplikacji, począwszy od zaawansowanej wizualizacji w formie dashboardu, interaktywnego raportu, po złożoną aplikację, która rozmawia z naszą bazą danych.

W tym artykule pokażemy jak łatwo zbudować aplikację czata z wykorzystaniem polskiego modelu językowego Bielik. To model stworzony przez SpeakLeash i ACK Cyfronet AGH. Jest to model wyspecjalizowany w przetwarzaniu i zgodny z polskim kontekstem języokowym. Dzięki temu, że model jest otwarty, można go douczyć na własnych danych, aby sprawniej działał zgodnie z naszymi potrzebami.

Do zbudowania czata wykorzystujemy notatnik Pythonowy oraz bibliotekę Mercury, która jest open source na licencji Apache-2.0. Repozytorium Mercurego to github.com/mljar/mercury , a dokumentacja jest dostępna na stronie RunMercury.com.

Obie technologie Mercury i Bielik powstają w Polsce, świetnie razem rezonują i są doskonałymi narzędziami do dalszego tworzenia.

1. Uruchomienie Bielika lokalnie

Do uruchomienia Bielika na moim komputerze używam oprogramowania ollama, do pobrania ze strony ollama.com. Żeby pobrać model uruchamiam komendę:

ollama run SpeakLeash/bielik-11b-v3.0-instruct:Q4_K_M

Pobranie zajmuje kilka minut, po tym czasie mogę swobodnie rozmawiać z modelem w terminalu:

2. Potrzebne pakiety

Do stworzenia kompletnej aplikacji potrzebujemy dwóch pakietów:

• ollama do komunikacji z Bielikiem,
• mercury do stworzenia aplikacji,

Ich nieskomplikowana instalacja wymaga jedynie wpisania komendy:

pip install ollama mercury

Do edytowania notatnika można użyć JupyterLab albo MLJAR Studio.

3. Budowanie czata

Otwieramy nowy notatnik Pythonowy. Pierwszym krokiem jest import potrzebnych paczek:

import ollama
import mercury as mr

W kolejnej komórce z kodem dodajemy zmienną messages która będzie listą wiadomości. Dzięki niej Bielik będzie wiedział o całej naszej rozmowie:

# list with all user and assistant messages
messages = []

W kolejnej komórce tworzymy miejsce gdzie będą wyświetlane wiadomości. Używamy do tego widgeta Chat z pakietu Mercury. W nim będą wyświetlane wszystkie wiadomości.

# place to display messages
chat = mr.Chat(placeholder="💬 Brak wiadomości, zacznij konwersację")

Potrzebujemy miejsca, w którym użytkownik będzie mógł wpisać swoją wiadomość. Używamy do tego ChatInput. Miejsce na wpisanie prompta będzie wyświetlane na dole aplikacji:

# user input
prompt = mr.ChatInput(placeholder="Napisz wiadomość ...")

Tak prezentują się elementy składowe naszej aplikacji:

Pakiet Mercury upraszcza budowanie aplikacji, ponieważ interakcja z widgetem poprostu wywołuje ponowne wykonanie komórek pod widgetem. Wystarczy dodać komórkę z kodem do obsługi prompta, który zostanie uruchomiony po wprowadzeniu wiadomości przez użytkownika.

if prompt.value:
    # create user message
    usr_msg = mr.Message(markdown=prompt.value, role="user")
    # display user message in the chat
    chat.add(usr_msg)
    # save in messages list
    messages += [{'role': 'user', 'content': prompt.value}]

    # call local LLM 🇵🇱
    stream = ollama.chat(
      model='SpeakLeash/bielik-11b-v3.0-instruct:Q4_K_M',
      messages=messages,
      stream=True,
    )

    # create assistant message
    ai_msg = mr.Message(role="assistant", emoji="🦅")
    # display assistant message in the chat
    chat.add(ai_msg)

    # stream with response
    content = ""
    for chunk in stream:
        ai_msg.append_markdown(chunk.message.content)
        content += chunk.message.content

    # save assistant response
    messages += [{'role': 'assistant', 'content': content}]

Powyższy kod można podzielić na następujące kroki:

• jeżeli jest nowa wartość prompta to wchodzimy w warunek,
• tworzymy wiadomość użytkownika, dodajemy ją do czata, i zapamiętujemy w liście wiadomości,
• następnie wysyłamy nasze wiadomości do Bielika przy użyciu pakietu ollama. Warto zauważyć, że mamy podany argument stream=True - to znaczy, że będziemy wyświetlać tekst dokładnie w takiej formie, w jakiej zwraca go model. Dzięki temu użytkownik będzie miał wrażenie, że model rzeczywiście do niego pisze. Gdybyśmy ustawili stream=False to ollama czekała by na całą wiadomość od Bielika i dopiero wtedy całość byłaby wyświetlana.
• ostatnim krokiem w naszym kodzie, jest stworzenie widomości z Bielika, dodawanie w niej zwracanego tekstu z modelu (funkcja ai_msg.append_markdown()), oraz zapamiętanie końcowej wiadomości w liście messages.

Pakiet Mercury daje możliwość wyświetlenia podglądu aplikacji w trakcie jej budowania. Tak wygląda czat w procesie tworzenia:

Fajnie :)

4. Aplikacja czat z Bielikiem

Dla naszego użytkownika końcowego chcemy wyświetlić tylko aplikację końcową. Nie straszymy kodem użytkowników! Żeby uruchomić serwer Mercury wystarczy uruchomić komendę:

mercury

Serwer wyszukuje wszystkie notatniki w bieżącym katalogu i wyświetla stronę startową:

Wybieramy naszą aplikację i możemy rozmawiać w naszym ojczystym języku z polskim modelem językowym, w aplikacji zbudowanej za pomocą polskiego pakietu Mercury:

Coś pięknego!

Podsumowanie

A niechaj narodowie wżdy postronni znają, iż Polacy nie gęsi, iż swoje AI technologie mają.

Nie ukrywam - to trochę wzruszające. Mercury powstaje w Polsce. Bielik powstaje w Polsce. A razem pozwalają budować nowoczesne aplikacje AI, które jeszcze kilka lat temu wymagały całych zespołów frontendowych, backendowych i ML-owych.

Dziś wystarczy:

• notatnik Python,
• kilka widgetów,
• lokalny model językowy.

I nagle mamy:

• aplikację webową,
• interfejs typu chat,
• model LLM działający na własnym komputerze,
• pełną kontrolę nad danymi.

To dopiero początek. Taki chat można łatwo rozbudować o:

• rozmowę z bazą danych,
• generowanie wykresów,
• analizę plików,
• dashboardy,
• wewnętrzne narzędzia firmowe,
• asystentów do dokumentów,
• edukacyjne aplikacje AI.

I to wszystko bez budowania frontendu od zera.

Mercury skraca drogę od pomysłu do działającej aplikacji. Bielik daje model, który rozumie polski język i kontekst. Razem tworzą fundament pod polskie aplikacje AI nowej generacji.

Jeśli budujesz narzędzia, robisz analizy, tworzysz systemy ML albo po prostu chcesz eksperymentować z LLM-ami - to jest świetny moment, żeby zacząć.

Bo przyszłość AI nie dzieje się gdzieś tam. Ona dzieje się tu. I możesz ją współtworzyć. 🇵🇱🚀