Ein Multi-Agent-Blogger mit null API-Kosten auf einem Mac: Gemma 4, Ollama und Google ADK

Ein Planungs- und Schreibagent kann vollständig auf einem Laptop laufen. Alles, was unten beschrieben wird, findet auf einem Apple Silicon Mac statt – ohne Gebühren pro Anfrage: Gemma 4, bereitgestellt von Ollama, das Google Agent Development Kit (ADK), das die Agenten verwaltet, sowie LiteLLM, das beide miteinander verbindet.

Sprachmodelle entwickeln sich weiter als reine Frage-und-Antwort-Systeme. Auf ihnen basierende Anwendungen interpretieren ein Ziel, entwerfen einen Plan, rufen Tools auf, bewerten die Ergebnisse und übergeben die Arbeit an spezialisierte Agenten. Viele Anleitungen für solche Systeme setzen auf bezahlte Cloud-APIs, was zwar praktisch ist, aber Nutzungskosten, API-Schlüsselverwaltung, Rate Limits sowie Fragen bezüglich der Datennutzung mit sich bringt. Die Lokalisierung beseitigt die tokenbasierte Abrechnung. Dadurch wird die Berechnung jedoch nicht kostenlos, da weiterhin Speicher, Rechenzeit, Speicherplatz und Strom verbraucht werden.

Das entwickelte System

Das Projekt plant, schreibt und überprüft einen technischen Blogartikel. Bei gegebener Thematik erarbeitet es die Schritte, erstellt einen strukturierten Überblick, schreibt den Artikel und bewertet den Entwurf. Dadurch werden zwei grundlegende Aspekte künstlicher Intelligenzen in agierender Form trainiert: das Schlussfolgern und das Handeln. Fünf Komponenten übernehmen die Arbeit:

• Ein Planungsagent, der den Artikelüberblick entwirft.
• Ein Überblicksprüfer, der überprüft, ob der Plan den Anforderungen entspricht.
• Ein Schreibagent, der den genehmigten Überblick in einen vollständigen Artikel umwandelt.
• Ein Artikelprüfer, der Struktur und technische Klarheit überprüft.
• Ein Leitagent, der den gesamten Ablauf koordiniert.

Das Design folgt dem eigenen Google-Codelab „Build an AI Agent with Google ADK“, mit einer Abweichung: Das gehostete Gemini-Modell wird durch Gemma 4 ersetzt, das lokal über Ollama läuft.

Modellwahl

Gemma 4 ist eine neuere Familie offener Modelle von Google DeepMind mit multimodalem Eingang, Schlussfolgerungsvermögen, Werkzeugnutzung und Codeunterstützung. Diese Konfiguration verwendet:

gemma4:e4b

Die E4B-Bezeichnung bezieht sich auf die effektive Anzahl der gleichzeitig aktiven Parameter und soll eine höhere Leistungsfähigkeit ohne die Verwendung aller Parameter bei jeder Eingabe ermöglichen. Die Ollama-Version ist etwa 9,6 GB groß und sollte auf einem Mac mit 16 GB integrierter Speicher funktionieren, wobei jedoch nur wenig Speicher für andere Anwendungen übrig bleibt. Bei Geräten mit begrenzten Ressourcen gibt es eine kleinere Variante:

gemma4:e2b

Es gibt etwas an Rechenqualität auf, um Geschwindigkeit und einen geringeren Speicherverbrauch zu erreichen.

Die Referenzmaschine war ein Apple M1 Pro mit einem 10-Kern-Prozessor, 16 GB integriertem Speicher, macOS, Python 3.13, Homebrew und Ollama. Andere Systeme, die von Ollama unterstützt werden, sollten ebenfalls funktionieren, obwohl sich die Installationsanweisungen und die Geschwindigkeit unterscheiden können.

Schritt 1: Ollama installieren

Ollama ist eine einfache Möglichkeit, offene Modelle lokal herunterzuladen und auszuführen. Mit Homebrew:

brew install ollama

Falls es bereits installiert ist, aktualisieren Sie es:

brew update
brew upgrade ollama

Bestätigen Sie die Installation:

ollama --version

Die macOS-App von der offiziellen Ollama-Website ist eine Alternative.

Schritt 2: Das Modell herunterladen

Herunterladen Sie das E4B-Modell. Rechnen Sie mit einigen Minuten, da die Datei einige Gigabyte groß ist:

ollama pull gemma4:e4b

Überprüfen Sie anschließend, ob es aufgelistet ist:

ollama list

Der Eintrag sollte ungefähr so aussehen:

NAME            ID              SIZE
gemma4:e4b      ...             9.6 GB

Schritt 3: sprechen Sie direkt mit dem Modell

Bevor Sie ADK hinzufügen, überprüfen Sie, ob Gemma allein über Ollama funktioniert:

ollama run gemma4:e4b

Probieren Sie einen einfachen Prompt aus:

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

Jede vernünftige Antwort zeigt, dass das lokale Modell funktioniert. Beenden Sie die interaktive Sitzung mit:

/bye

Diese Testung isoliert Probleme. Wenn das Modell hier versagt, ist das Debuggen des Agent-Frameworks sinnlos.

Schritt 4: Überprüfen, ob Ollama bereits läuft

Standardmäßig hört Ollama auf:

http://127.0.0.1:11434

Das Manuell-Starten des Servers kann zu einem Fehler führen:

ollama serve

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

Dieser Fehler bedeutet nicht unbedingt ein Problem. In der Regel bedeutet er, dass Ollama bereits läuft. Testen Sie es mit einer Anfrage an den Tags-Endpunkt:

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

Ein laufender Server antwortet mit JSON, in dem die installierten Modelle aufgelistet sind. Um zu sehen, welche Modelle derzeit geladen sind:

ollama ps

Ein zweiter Server sollte niemals auf derselben Portnummer gestartet werden.

Schritt 5: ADK-Projekt erstellen

Erstellen Sie einen Projektordner an einem geeigneten Ort:

cd /Users/yourusername
mkdir bloggeragent
cd bloggeragent

Erstellen Sie die Dateien, die das Projekt benötigt:

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

Die Gestaltung sollte wie folgt aussehen:

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

Schritt 6: eine virtuelle Umgebung

Eine Python-Virtuelle Umgebung hält die Abhängigkeiten des Projekts von dem Rest des Systems getrennt. Erstellen Sie eine:

python3 -m venv .venv

Aktivieren Sie es:

source .venv/bin/activate

Der Terminal-Befehl sollte nun mit folgendem beginnen:

(.venv)

Überprüfen Sie, ob der richtige Interpreter verwendet wird:

which python

Der zurückgegebene Pfad sollte auf einen Ort innerhalb der Projektumgebung verweisen, etwa so:

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

Schritt 7: ADK mit Unterstützung für lokale Modelle installieren

Fügen Sie die Abhängigkeiten in requirements.txt ein:

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

Dann installieren Sie sie:

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

Der [extensions]-Teil ist wichtig. Eine einfache ADK-Installation weist möglicherweise die optionalen Pakete nicht auf, die der LiteLlm-Wrapper benötigt, wodurch die Anwendung mit einem Importfehler fehlschlagen kann:

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

Falls das erscheint, installieren Sie die Zusatzkomponenten ausdrücklich:

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

Absatzzeichen verhindern, dass Shell-Programme wie Zsh die eckigen Klammern als Muster behandeln. Um die Integration zu überprüfen:

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

Die erwartete Ausgabe ist:

LiteLLM connection ready

Schritt 8: Weisen Sie das Projekt auf Ollama hin

Fügen Sie die lokale Adresse zu .env hinzu:

OLLAMA_API_BASE=http://127.0.0.1:11434

Im Gegensatz zur gehosteten Gemini-Version benötigt die lokale Einrichtung keinen Google API-Schlüssel, daher ist diese Variable nicht vorhanden:

GOOGLE_API_KEY

Die lokale Konfiguration ist weiterhin zu schützen, daher fügen Sie diese Einträge zu .gitignore hinzu:

.env
.venv/
__pycache__/
*.pyc

Es ist eine gute Praxis, .env außerhalb des Versionskontrollsystems zu belassen, selbst wenn die Datei derzeit keine Geheimnisse enthält.

Schritt 9: Ordner zu einem Paket machen

Fügen Sie eine Zeile zu __init__.py hinzu, damit ADK die Agentendefinition aus dem Paket importieren kann:

from . import agent

Schritt 10: Definieren des lokalen Modells

Öffnen Sie agent.py und beginnen Sie mit den Imports:

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

Laden Sie die Umgebungskonfiguration:

load_dotenv()

Erstellen Sie den Anschluss zum lokalen Modell:

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

Google empfiehlt den Anbieter ollama_chat vor dem einfachen ollama. Die für Chats optimierte Schnittstelle bewahrt den Konversationskontext besser und verringert die Wahrscheinlichkeit unangemessener, wiederholter Aufrufe von Tools. Bei dem kleineren Modell ändert sich nur der Modellstring:

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

Schritt 11: der Mehr-Agenten-Arbeitsablauf

Der vollständige Mehr-Agenten-Code stammt aus Googles codelab, genauer aus dem Schritt zur Erstellung eines Mehr-Agenten-Blogautors. Der bereitgestellte Code wird in agent.py abgelegt. Er definiert folgende Komponenten:

• BlogPlanner erstellt den Überblick.
• OutlineValidationChecker prüft diesen Überblick.
• RobustBlogPlanner führt die Planung sowie diese Prüfung innerhalb einer Schleife mit fester Grenze durch.
• BlogWriter erweitert den Überblick zu einem Artikel.
• BlogPostValidationChecker überprüft den fertigen Text.
• RobustBlogWriter verknüpft das Schreiben mit dieser Überprüfung.
• planner_tool und writer_tool stellen die beiden Arbeitsabläufe als aufrufbare Tools bereit.
• root_agent steuert den Prozess von Anfang bis Ende.

Im Original sprechen diese Agenten mit einem gehosteten Gemini-Modell. Die Architektur bleibt unverändert, nur die Konfiguration des Modells ändert sich.

Wie im Codelab enthält __init__.py folgendes:

from . import agent

Dadurch wird der Agent-Arbeitsablauf dem ADK-Runner ausgesetzt. Anschließend passen Sie die Importe in agent.py des Codelabs an. Fügen Sie den Import von LiteLlm hinzu:

from google.adk.models.lite_llm import LiteLlm

Diese beiden Importe werden im bereitgestellten Code nicht verwendet und können entfernt werden:

import sys
from pathlib import Path

Diese bleiben erhalten:

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

Das Codelab definiert sein Modell durch eine Abfrage des Umfelds:

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

Ersetzen Sie diese Zeile durch den lokalen Connector:

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

Der Anfang von agent.py sollte dann wie folgt aussehen:

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"
)

Die Definitionen des Planers, Schreibers, Validierer sowie von LoopAgent, AgentTool und root_agent bleiben genau so, wie sie im Codelab dargestellt werden. Jeder Agent verfügt bereits über:

model=MODEL

Durch Änderung der gemeinsam genutzten MODEL-Variable wird das gesamte System von der gehosteten Gemini-API auf Gemma 4 umgeleitet, das über Ollama läuft.

Was dieses Projekt trainiert

In diesem kleinen Projekt kommen mehrere Agentenkonzepte zusammen:

• Logikverarbeitung: Gemma interpretiert das Ziel und entscheidet sich für einen Ansatz.
• Planung: der Planungsagent erstellt einen Überblick.
• Ausführung: der Root-Agent ruft die spezialisierten Arbeitsabläufe auf.
• Werkzeugnutzung: Planung und Schreiben werden als Agentenwerkzeuge bereitgestellt.
• Gemeinsamer Zustand: Ergebnisse werden vom Planer an den Schreiber sowie die Überprüfer weitergegeben.
• Validierung: spezielle Überprüfungsagenten prüfen jede Zwischenergebnis.
• Orchestrierung: ein Root-Agent entscheidet, was wann ausgeführt wird.
• Iteration: Begrenzte Schleifen ermöglichen Überarbeitungen.
• Lokaler Schlussfolgerungsprozess: Ollama führt Gemma 4 auf dem Mac aus.

Zusammen zeigen sie ein lokal gehostetes Sprachmodell, das als Reasoning-Engine innerhalb eines größeren agierenden Systems fungiert.

Ausführung der fertigen Version

Eine vollständige Implementierung mit Planer, Schreiber, Validatoren, der lokalen Gemma 4-Konfiguration sowie dem Hauptagenten ist in einem GitHub-Repositorium namens bloggeragent veröffentlicht. Um es zu verwenden, klonen Sie es:

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

Erstellen und aktivieren Sie eine virtuelle Umgebung:

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

Installieren Sie die Abhängigkeiten:

python -m pip install -r requirements.txt

Das ist die vollständige lokale Anpassung des Blog-Schreibbeispiels von Google, die für Gemma 4 über Ollama und LiteLLM statt über die gehostete Gemini-API eingerichtet wurde.

Die Schlussfolgerung

Ein KI-Agent benötigt nicht immer eine kostenpflichtige Modell-API. Mit Gemma 4, Ollama, LiteLLM und Google ADK kann eine Mehr-Agenten-Anwendung einen Artikel planen, den Plan überprüfen, einen Entwurf schreiben, diesen durchsehen und das Ergebnis auf einem Apple Silicon Mac ohne Gebühren pro Anfrage liefern. Der lokale Betrieb macht es außerdem einfacher, zu erkennen, wie Agentensysteme unter der Chat-Oberfläche funktionieren.

Die wichtigste Erkenntnis ist, dass ein Agent mehr ist als nur sein Sprachmodell. Ein leistungsstarker Agent entsteht durch die Kombination aus Modell, Anweisungen, Werkzeugen, Zustand, Orchestrierung, Validierung und Schutzmaßnahmen. Die lokale Ausführung des Modells bietet mehr Kontrolle über die Infrastruktur, und die Gestaltung des Systems entscheidet darüber, ob diese Kontrolle zu etwas Nützlichem, Zuverlässigem und Verantwortungsvollem führt.