Un blogueur multi-agents sans coût API sur Mac : Gemma 4, Ollama et Google ADK

Un agent de planification et d’écriture peut fonctionner entièrement sur un ordinateur portable. Tout ce qui est décrit ci-dessous s’effectue sur un Mac Apple Silicon, sans frais par requête : Gemma 4 géré par Ollama, le Google Agent Development Kit (ADK) qui gère les agents, et LiteLLM qui relie les deux.

Les modèles de langage dépassent le cadre des questions-réponses. Les applications développées à leur base interprètent un objectif, élaborent un plan, utilisent des outils, évaluent les résultats et transmettent le travail à des agents spécialisés. De nombreux tutoriels sur de tels systèmes reposent sur des API cloud payantes, ce qui est pratique mais entraîne des frais d’utilisation, des problèmes de gestion des clés API, des limites de fréquence et des questions concernant la destination des données. Le passage à une solution locale élimine la facturation basée sur les tokens. Cela ne rend pas le calcul gratuit, car de la mémoire, du temps de traitement, de l’espace de stockage et de l’électricité sont toujours consommés.

Le système en cours de développement

Le projet planifie, rédige et évalue un article de blog technique. Une fois le sujet défini, il détermine les étapes à suivre, crée un plan structuré, rédige l’article et évalue le brouillon. Cela met en œuvre deux composantes fondamentales de l’IA agente : le raisonnement et l’action. Cinq composants assurent ce travail :

• Un agent planificateur qui élabore le plan de l’article.
• Un validateur de plan qui vérifie si le plan répond aux exigences.
• Un agent rédacteur qui transforme le plan approuvé en un article complet.
• Un validateur d’article qui examine la structure et la clarté technique.
• Un agent principal qui coordonne l’ensemble du processus.

La conception s’inspire du codelab de Google intitulé « Build an AI Agent with Google ADK », avec une modification : le modèle Gemini hébergé est remplacé par Gemma 4 exécuté localement via Ollama.

Choix du modèle

Gemma 4 est une nouvelle famille de modèles ouverts de Google DeepMind offrant une prise en charge des entrées multimodales, du raisonnement, de l’utilisation d’outils et de la programmation. Cette configuration utilise :

gemma4:e4b

La étiquette E4B fait référence au nombre effectif de paramètres actifs à un moment donné, afin d’offrir des capacités accrues sans devoir activer tous les paramètres pour chaque entrée. La version Ollama pèse environ 9,6 GB et devrait fonctionner sur un Mac disposant de 16 GB de mémoire unifiée, bien que peu de mémoire reste disponible pour d’autres applications. Sur des machines moins puissantes, une version plus légère existe :

gemma4:e2b

Il sacrifie une certaine qualité de raisonnement au profit de la vitesse et d’une empreinte mémoire plus faible.

La machine de référence était un Apple M1 Pro doté d’un processeur à 10 cœurs, de 16 GB de mémoire unifiée, de macOS, de Python 3.13, de Homebrew et d’Ollama. D’autres systèmes pris en charge par Ollama devraient également fonctionner, bien que les commandes d’installation et les vitesses varient.

Étape 1 : installer Ollama

Ollama est un moyen simple de télécharger et d’exécuter des modèles ouverts localement. Avec Homebrew :

brew install ollama

Si il est déjà installé, mettez-le à jour :

brew update
brew upgrade ollama

Confirmer l’installation :

ollama --version

L’application macOS disponible sur le site officiel d’Ollama constitue une alternative.

Étape 2 : télécharger le modèle

Téléchargez le modèle E4B. Prévoyez quelques minutes, car le fichier fait plusieurs gigaoctets :

ollama pull gemma4:e4b

Vérifiez ensuite qu’il est listé :

ollama list

La entrée devrait ressembler à peu près à ceci :

NAME            ID              SIZE
gemma4:e4b      ...             9.6 GB

Étape 3 : parler directement au modèle

Avant d’ajouter ADK, vérifiez que Gemma fonctionne seule via Ollama :

ollama run gemma4:e4b

Essayez une instruction simple :

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

Toute réponse sensée montre que le modèle local fonctionne. Quittez la session interactive avec :

/bye

Ce test permet d’isoler les problèmes. Si le modèle échoue ici, déboguer le framework de l’agent est inutile.

Étape 4 : vérifier si Ollama est déjà en cours d’exécution

Par défaut, Ollama écoute sur :

http://127.0.0.1:11434

Le démarrage manuel du serveur peut provoquer une erreur :

ollama serve

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

Cette erreur ne signifie pas nécessairement un problème. Elle indique généralement que Ollama est déjà en marche. Testez-le en envoyant une requête à l’endpoint des tags :

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

Un serveur en cours d’exécution répond par un JSON qui liste les modèles installés. Pour voir quels modèles sont actuellement chargés :

ollama ps

Un deuxième serveur ne doit jamais être démarré sur le même port.

Étape 5 : créer le projet ADK

Créez un dossier de projet à l’endroit qui vous convient :

cd /Users/yourusername
mkdir bloggeragent
cd bloggeragent

Créez les fichiers nécessaires au projet :

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

Le layout doit ressembler à ceci :

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

Étape 6 : un environnement virtuel

Un environnement virtuel Python isole les dépendances du projet du reste du système. Créez-en un :

python3 -m venv .venv

Activez-le :

source .venv/bin/activate

Le prompt de terminal doit maintenant commencer par :

(.venv)

Vérifiez que l’interpréteur approprié est utilisé :

which python

Le chemin retourné doit pointer à l’intérieur de l’environnement du projet, quelque chose comme :

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

Étape 7 : installer ADK avec prise en charge des modèles locaux

Placez les dépendances dans requirements.txt :

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

Ensuite, installez-les :

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

La partie [extensions] est importante. Une installation de base d’ADK peut ne pas contenir les paquets optionnels nécessaires au wrapper LiteLlm, ce qui peut entraîner une erreur d’importation et l’échec de l’application :

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

Si cela apparaît, installez les éléments supplémentaires explicitement :

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

Les guillemets empêchent des interpréteurs comme Zsh de traiter les crochets carrés comme un motif. Pour vérifier l’intégration :

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

Le résultat attendu est :

LiteLLM connection ready

Étape 8 : diriger le projet vers Ollama

Ajoutez l’adresse locale dans .env :

OLLAMA_API_BASE=http://127.0.0.1:11434

Contrairement à la version Gemini hébergée, la configuration locale n’a pas besoin de clé API Google, donc cette variable est absente :

GOOGLE_API_KEY

La configuration locale mérite toujours d’être protégée, donc ajoutez ces entrées à .gitignore :

.env
.venv/
__pycache__/
*.pyc

Il est bon de ne pas inclure le fichier .env dans le contrôle de version, même s’il ne contient actuellement aucun secret.

Étape 9 : transformer le dossier en package

Ajoutez une ligne dans __init__.py afin que ADK puisse importer la définition de l’agent depuis le package :

from . import agent

Étape 10 : définir le modèle local

Ouvrez agent.py et commencez par les importations :

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

Chargement de la configuration de l’environnement :

load_dotenv()

Créez le connecteur vers le modèle local :

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

Google recommande le fournisseur ollama_chat plutôt que le simple ollama. L’interface spécifique aux chats permet de conserver mieux le contexte de la conversation et réduit le risque d’appels répétés inappropriés aux outils. Avec le modèle plus petit, seule la chaîne de caractères du modèle change :

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

Étape 11 : le flux de travail multi-agents

Le code complet pour le système multi-agents provient du codelab de Google, dans l’étape relative à la création d’un écrivain de blogs multi-agents. Le code fourni est placé dans agent.py. Il définit les éléments suivants :

• BlogPlanner génère l’aperçu du contenu.
• OutlineValidationChecker le vérifie.
• RobustBlogPlanner exécute la planification ainsi que cette vérification à l’intérieur d’une boucle ayant une limite fixe.
• BlogWriter développe l’aperçu en un article complet.
• BlogPostValidationChecker examine le texte finalisé.
• RobustBlogWriter associe l’écriture à cette vérification.
• planner_tool et writer_tool présentent les deux flux de travail sous forme d’outils pouvant être appelés.
• root_agent pilote le processus du début à la fin.

Dans la version originale, ces agents communiquent avec un modèle Gemini hébergé. L’architecture reste identique, seules la configuration du modèle change.

Comme dans le codelab, __init__.py contient :

from . import agent

Cela expose le flux de travail de l’agent au lanceur ADK. Ensuite, modifiez les importations dans le fichier agent.py du codelab. Ajoutez l’importation de LiteLlm :

from google.adk.models.lite_llm import LiteLlm

Ces deux importations ne sont pas utilisées dans le code fourni et peuvent être supprimées :

import sys
from pathlib import Path

Ceux-ci restent :

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

Le codelab définit son modèle en effectuant une recherche dans l’environnement :

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

Remplacez cette ligne par le connecteur local :

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

Le début de agent.py devrait alors ressembler à ceci :

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

Les définitions du planificateur, de l’auteur, des validateurs, de LoopAgent, de AgentTool et de root_agent restent exactement telles que les présente le codelab. Chaque agent dispose déjà de :

model=MODEL

En modifiant la seule variable MODEL partagée, on redirige tout le système de l’API Gemini hébergée vers Gemma 4 fonctionnant via Ollama.

Ce que cet exercice met en pratique

Plusieurs concepts d’agents se retrouvent dans ce petit projet :

• Raisonnement : Gemma interprète l’objectif et choisit une approche.
• Planification : l’agent planificateur élabore un plan général.
• Action : l’agent principal invoque les workflows spécialisés.
• Utilisation d’outils : la planification et l’écriture sont présentées comme des outils d’agent.
• État partagé : les résultats sont transmis du planificateur à l’écriteur et aux vérificateurs.
• Validation : des agents vérificateurs dédiés examinent chaque sortie intermédiaire.
• Orchestration : un agent principal décide de ce qui s’exécute et quand.
• Itération : les boucles bornées permettent des révisions.
• Inférence locale : Ollama exécute Gemma 4 sur le Mac.

Ensemble, ils montrent un modèle de langage hébergé localement qui agit comme moteur de raisonnement au sein d’un système agent plus vaste.

Exécution de la version finale

Une implémentation complète, incluant un planificateur, un écrivain, des validateurs, la configuration locale de Gemma 4 ainsi que l’agent principal, est publiée dans un répertoire GitHub nommé bloggeragent. Pour l’utiliser, clonez-le :

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

Créez et activez un environnement virtuel :

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

Installez les dépendances :

python -m pip install -r requirements.txt

Ce texte représente l’adaptation locale complète de l’exemple de rédaction de blog de Google, configuré pour Gemma 4 à l’aide d’Ollama et LiteLLM plutôt que via l’API Gemini hébergée.

Le point clé

Un agent IA n’a pas toujours besoin d’une API de modèle payante. Avec Gemma 4, Ollama, LiteLLM et Google ADK, une application multi-agents peut planifier un article, valider ce plan, rédiger un brouillon, le relire et restituer le résultat sur un Mac Apple Silicon, sans frais par requête. Le fait de l’exécuter localement permet également de mieux comprendre le fonctionnement des systèmes d’agents en dehors de l’interface de chat.

La leçon principale est qu’un agent est bien plus que son modèle de langage. Un agent performant naît de la combinaison d’un modèle, d’instructions, d’outils, d’un état, d’une orchestration, d’une validation et de mécanismes de sécurité. Exécuter le modèle localement offre un contrôle accru sur l’infrastructure, et la conception du système qui l’entoure détermine si ce contrôle permet d’obtenir des résultats utiles, fiables et responsables.