Blogger wieloagentowy bez kosztów API na Macu: Gemma 4, Ollama i Google ADK

Agenty do planowania i pisania mogą działać wyłącznie na laptopie. Wszystko poniżej odbywa się na komputerze Mac z procesorem Apple Silicon bez żadnych opłat za każdą prośbę: Gemma 4 obsługiwana przez Ollamę, narzędzie Google’s Agent Development Kit (ADK) do zarządzania agentami oraz LiteLLM łączące te elementy.

Modele językowe wykraczają poza prosty model pytanie-odpowiedź. Aplikacje zbudowane na ich bazie interpretują cel, opracowują plan, wykorzystują odpowiednie narzędzia, oceniają wyniki i przekazują zadania specjalistycznym agentom. Wiele instrukcji dotyczących takich systemów opiera się na płatnych usługach chmurowych API, co jest wygodne, ale wiąże się z opłatami za korzystanie, koniecznością zarządzania kluczami API, ograniczeniami szybkości oraz pytaniami dotyczącymi przeznaczenia danych. Przeniesienie działania na lokalny sprzęt eliminuje opłaty oparte na tokenach. Nie czyni to obliczeń darmowymi, ponieważ nadal zużywa się pamięć, czas procesora, przestrzeń magazynową oraz energię elektryczną.

System, który jest budowany

Projekt planuje, pisze i sprawdza artykuł na blogu technicznym. Na podstawie określonego tematu wyznacza kroki realizacji, tworzy ustrukturyzowany plan, pisze tekst i ocenia wersję roboczą. Dzięki temu ćwiczone są dwie podstawowe funkcje sztucznej inteligencji agentowej: rozumowanie i działanie. Pracę tę wykonywają pięć komponentów:

• Agent planistyczny, który tworzy szkic artykułu.
• Walidator planu, który sprawdza, czy plan spełnia wymagania.
• Agent pisarski, który przekształca zatwierdzony plan w pełny artykuł.
• Walidator artykułu, który sprawdza strukturę i klarowność techniczną.
• Agent nadrzędny, który koordynuje cały proces.

Projekt opiera się na własnym codelabie Google „Build an AI Agent with Google ADK”, z jedną zmianą: zamiast modelu Gemini hostowanego online używany jest Gemma 4 uruchamiany lokalnie za pomocą Ollamy.

Wybór modelu

Gemma 4 to nowsza seria modeli otwartych od Google DeepMind, posiadająca funkcje obsługi danych wielomodalnych, rozumowania, używania narzędzi oraz wspierania programowania. W tym rozwiązaniu wykorzystano:

gemma4:e4b

Etykieta E4B odnosi się do faktycznej liczby aktywnych parametrów w danym momencie i ma na celu zapewnienie lepszych możliwości bez konieczności wykorzystywania wszystkich parametrów przy każdym wprowadzonym danych. Wersja Ollamy zajmuje około 9,6 GB pamięci i powinna działać na Macu z 16 GB pamięci zintegrowanej, chociaż niewiele miejsca pozostanie na inne aplikacje. W przypadku komputerów o ograniczonych możliwościach dostępna jest mniejsza wersja:

gemma4:e2b

Rezygnuje ono z pewnej jakości rozumowania w zamian za szybkość i mniejsze zużycie pamięci.

Maszyną referencyjną był Apple M1 Pro z procesorem 10-jądrowym, 16 GB pamięci zintegrowanej, systemem macOS, Pythonem 3.13, Homebrew oraz Ollamą. Inne systemy obsługiwane przez Ollamę powinny również działać, chociaż polecenia instalacji i szybkość będą się różnić.

Krok 1: instalacja Ollamy

Ollama to prosty sposób na pobieranie i uruchamianie modeli otwartych lokalnie. Za pomocą Homebrew:

brew install ollama

Jeśli jest już zainstalowane, zaktualizuj je:

brew update
brew upgrade ollama

Potwierdź instalację:

ollama --version

Aplikacja dla macOS z oficjalnej strony Ollama stanowi alternatywę.

Krok 2: pobranie modelu

Pobierz model E4B. Oczekuj kilku minut, ponieważ plik ma rozmiar kilku gigabajtów:

ollama pull gemma4:e4b

Następnie sprawdź, czy jest ono wymienione:

ollama list

Wpis powinien wyglądać mniej więcej tak:

NAME            ID              SIZE
gemma4:e4b      ...             9.6 GB

Krok 3: rozmawiaj bezpośrednio z modelem

Zanim dodasz ADK, sprawdź, czy Gemma działa sama poprzez Ollamę:

ollama run gemma4:e4b

Spróbuj prostego polecenia:

Create an outline for an article explaining AI agents to beginners.

Każda rozsądna odpowiedź pokazuje, że lokalny model funkcjonuje prawidłowo. Zakończ sesję interaktywną w następujący sposób:

/bye

To test pozwala zidentyfikować problemy. Jeśli model zawiedzie w tym przypadku, naprawianie frameworku agenta jest bezcelowe.

Krok 4: sprawdzenie, czy Ollama już działa

Domyślnie Ollama słucha na:

http://127.0.0.1:11434

Ręczne uruchomienie serwera może spowodować błąd:

ollama serve

Error: listen tcp 127.0.0.1:11434: bind: address already in use

Ten błąd niekoniecznie oznacza problemy. Zazwyczaj oznacza to, że Ollama jest już uruchomiony. Sprawdź to, wysyłając żądanie do endpointu tags:

curl http://127.0.0.1:11434/api/tags

Uruchomiony serwer odpowiada JSON-em, który wymienia zainstalowane modele. Aby zobaczyć, które modele są obecnie załadowane:

ollama ps

Nigdy nie należy uruchamiać drugiego serwera na tym samym porcie.

Krok 5: utworzenie projektu ADK

Stwórz folder projektu w miejscu, które Ci odpowiada:

cd /Users/yourusername
mkdir bloggeragent
cd bloggeragent

Stwórz pliki potrzebne do projektu:

touch requirements.txt .env .gitignore __init__.py agent.py

Struktura powinna wyglądać w ten sposób:

bloggeragent/
├── .env
├── .gitignore
├── __init__.py
├── agent.py
└── requirements.txt

Krok 6: środowisko wirtualne

Środowisko wirtualne w Pythonie oddziela zależności projektu od reszty systemu. Stwórz je:

python3 -m venv .venv

Aktywuj to:

source .venv/bin/activate

Pytanie w terminalu powinno teraz zaczynać się od:

(.venv)

Sprawdź, czy używany jest właściwy interpreter:

which python

Ścieżka zwrócona powinna wskazywać na obszar środowiska projektu, na przykład:

/Users/philipobiorah/bloggeragent/.venv/bin/python

Krok 7: zainstaluj ADK z obsługą lokalnych modeli

Umieść zależności w pliku requirements.txt:

google-adk[extensions]==2.2.0
python-dotenv
litellm>=1.84

Następnie zainstaluj je:

python -m pip install --upgrade pip
python -m pip install -r requirements.txt

Część [extensions] jest istotna. Podstawowa instalacja ADK może nie zawierać pakietów opcjonalnych, których potrzebuje wrapper LiteLlm, w wyniku czego aplikacja może zawieść z błędem importu:

ImportError: LiteLLM support requires:
pip install google-adk[extensions]

Jeśli to się pojawi, zainstaluj dodatki wyraźnie:

python -m pip install --upgrade "google-adk[extensions]==2.2.0"
python -m pip install --upgrade "litellm>=1.84"

W nawiasach cudzysłowowych skrypty takie jak Zsh nie traktują nawiasów kwadratowych jako wzoru. Aby sprawdzić integrację:

python -c "from google.adk.models.lite_llm import LiteLlm; print('LiteLLM connection ready')"

Oczekiwany wynik to:

LiteLLM connection ready

Krok 8: skierowanie projektu na Ollamę

Dodaj adres lokalny do pliku .env:

OLLAMA_API_BASE=http://127.0.0.1:11434

W odróżnieniu od wersji Gemini hostowanej online, lokalna konfiguracja nie wymaga klucza API Google, dlatego ta zmienna jest nieobecna:

GOOGLE_API_KEY

Konfiguracja lokalna nadal wymaga ochrony, dlatego dodaj te wpisy do pliku .gitignore:

.env
.venv/
__pycache__/
*.pyc

Zachowanie pliku .env poza systemem kontroli wersji to dobra praktyka, nawet jeśli obecnie nie zawiera on żadnych tajemnic.

Krok 9: przekształcenie folderu w pakiet

Dodaj jedną linię do pliku __init__.py, aby ADK mogło importować definicję agenta z tego pakietu:

from . import agent

Krok 10: zdefiniuj lokalny model

Otwórz plik agent.py i zacznij od importów:

import datetime

from dotenv import load_dotenv
from google.adk.agents import Agent, LoopAgent
from google.adk.models.lite_llm import LiteLlm
from google.adk.tools import agent_tool

Ładuj konfigurację środowiska:

load_dotenv()

Stwórz połączenie z lokalnym modelem:

MODEL = LiteLlm(
    model="ollama_chat/gemma4:e4b"
)

Google zaleca używanie dostawcy ollama_chat zamiast zwykłego ollama. Interfejs przeznaczony do czatów lepiej przechowuje kontekst rozmowy i zmniejsza ryzyko nieodpowiednich, powtarzających się wywołań narzędzi. W przypadku mniejszego modelu zmienia się jedynie jego nazwa:

MODEL = LiteLlm(
    model="ollama_chat/gemma4:e2b"
)

Krok 11: proces pracy z wieloma agentami

Pełny kod dla wielu agentów pochodzi z codelabu Google, konkretnie z części dotyczącej tworzenia narzędzia do pisania artykułów blogowych z wykorzystaniem wielu agentów. Dostarczony kod znajduje się w pliku agent.py. Definiuje on następujące elementy:

• BlogPlanner tworzy szkic artykułu.
• OutlineValidationChecker sprawdza ten szkic.
• RobustBlogPlanner wykonuje planowanie oraz tę weryfikację w pętli o ustalonej liczbie iteracji.
• BlogWriter rozwija szkic na pełny artykuł.
• BlogPostValidationChecker analizuje gotowy tekst.
• RobustBlogWriter łączy proces pisania z tą analizą.
• planner_tool i writer_tool przedstawiają oba procesy jako narzędzia, które można wywołać.
• root_agent kieruje całym procesem od początku do końca.

W oryginale te agenty rozmawiają z modelem Gemini uruchomionym na serwerze. Architektura pozostaje niezmieniona, zmienia się jedynie konfiguracja modelu.

Tak jak w codelabie, plik __init__.py zawiera:

from . import agent

To naraża proces pracy agenta na silnik ADK. Następnie skoryguj importy w pliku agent.py z codelabu. Dodaj import LiteLlm:

from google.adk.models.lite_llm import LiteLlm

Te dwa importy nie są używane w dostarczonym kodzie i można je usunąć:

import sys
from pathlib import Path

Te pozostają:

import datetime
from dotenv import load_dotenv
from google.adk.agents import Agent, LoopAgent
from google.adk.tools import agent_tool

Codelab definiuje swój model poprzez wyszukiwanie w środowisku:

MODEL = os.getenv("MODEL", "gemini-flash-latest")

Zastąp ten wiersz lokalnym łącznikiem:

MODEL = LiteLlm(
    model="ollama_chat/gemma4:e4b"
)

Na początku pliku agent.py powinno znajdować się następujące teksty:

import datetime

from dotenv import load_dotenv
from google.adk.agents import Agent, LoopAgent
from google.adk.models.lite_llm import LiteLlm
from google.adk.tools import agent_toolload_dotenv()MODEL = LiteLlm(
    model="ollama_chat/gemma4:e4b"
)

Definicje planera, pisarza, walidatorów, LoopAgent, AgentTool oraz root_agent pozostają dokładnie takie, jak przedstawiono je w codelabie. Każdy agent już zawiera:

model=MODEL

Zmiana tej jednej wspólnej zmiennej MODEL przekierowuje cały system z hostowanej API Gemini na Gemma 4 działającą przez Ollamę.

Co to ćwiczy

W tym małym projekcie łączą się kilka koncepcji agentów:

• Rozumowanie: Gemma interpretuje cel i decyduje o podejściu.
• Planowanie: agent planistyczny opracowuje zarys działania.
• Działanie: agent główny uruchamia specjalistyczne procesy.
• Używanie narzędzi: planowanie i pisanie są dostępne jako narzędzia agentów.
• Wspólny stan: wyniki są przekazywane od planisty do pisarza oraz sprawdzaczy.
• Walidacja: dedykowani agenci sprawdzający analizują każdy pośredni wynik.
• Orkiestracja: jeden agent główny decyduje, co i kiedy ma zostać uruchomione.
• Iteracja: pętle ograniczone umożliwiają korektę.
• Wnioskowanie lokalne: Ollama uruchamia Gemma 4 na Macu.

Wspólnie pokazują one model językowy hostowany lokalnie, który pełni rolę silnika rozumowania w ramach większego systemu agentowego.

Uruchamianie gotowej wersji

Pełna implementacja, wraz z planerem, pisarzem, walidatorami, konfiguracją lokalnego Gemma 4 oraz głównym agentem, została opublikowana w repozytorium GitHub o nazwie bloggeragent. Aby jej użyć, sklonuj je:

git clone https://github.com/philipobiorah/bloggeragent.git
cd bloggeragent

Stwórz i aktywuj środowisko wirtualne:

python3 -m venv .venv
source .venv/bin/activate

Zainstaluj zależności:

python -m pip install -r requirements.txt

To jest pełna lokalna adaptacja przykładu pisania blogów od Google, uruchomiona przy użyciu Gemma 4, Ollamy i LiteLLM zamiast hostowanej API Gemini.

Główny wniosek

Agent sztucznej inteligencji nie zawsze wymaga płatnej API modelu. Dzięki Gemma 4, Ollamie, LiteLLM oraz Google ADK aplikacja wieloagentowa może zaplanować artykuł, zweryfikować plan, napisać szkic, go przejrzeć i zwrócić wynik na komputerze z procesorem Apple Silicon bez opłat za każdą prośbę. Uruchomienie oprogramowania lokalnie ułatwia również zrozumienie, w jaki sposób systemy agentów działają pod interfejsem czatu.

Główną lekcją jest to, że agent to coś więcej niż tylko jego model językowy. Skuteczny agent powstaje w wyniku połączenia modelu, instrukcji, narzędzi, stanu, mechanizmów orkiestracji, weryfikacji oraz zabezpieczeń. Uruchamianie modelu lokalnie daje większą kontrolę nad infrastrukturą, a projekt systemu wokół niego decyduje o tym, czy ta kontrola przynosi coś użytecznego, niezawodnego i odpowiedzialnego.