Un bloguero multiagente sin costo de API en Mac: Gemma 4, Ollama y Google ADK

Un agente de planificación y redacción puede funcionar completamente en una laptop. Todo lo que se describe a continuación se lleva a cabo en una Mac con Apple Silicon, sin costos por solicitud: Gemma 4 proporcionada por Ollama, el Google Agent Development Kit (ADK) que gestiona los agentes, y LiteLLM que conecta ambos.

Los modelos de lenguaje están evolucionando más allá del formato de pregunta y respuesta. Las aplicaciones desarrolladas con ellos interpretan un objetivo, elaboran un plan, utilizan herramientas, evalúan los resultados y transfieren el trabajo a agentes especializados. Muchos tutoriales sobre estos sistemas dependen de APIs en la nube de pago, lo cual es conveniente pero implica costos de uso, gestión de claves API, límites de velocidad y dudas sobre el destino de los datos. Al trabajar de forma local se elimina la facturación basada en tokens. Esto no hace que el procesamiento sea gratuito, ya que aún se gastan memoria, tiempo de procesamiento, almacenamiento y electricidad.

El sistema que se está desarrollando

El proyecto planifica, escribe y revisa un artículo de blog técnico. Dado un tema, determina los pasos a seguir, elabora un esquema estructurado, escribe el artículo y evalúa el borrador. Esto ejercita dos componentes básicos de la IA agente: el razonamiento y la acción. Cinco componentes realizan el trabajo:

• Un agente planificador que elabora el esquema del artículo.
• Un validador de esquemas que verifica si el plan cumple con los requisitos.
• Un agente escritor que convierte el esquema aprobado en un artículo completo.
• Un validador de artículos que revisa la estructura y la claridad técnica.
• Un agente principal que coordina todo el proceso.

El diseño sigue el propio codelab de Google “Build an AI Agent with Google ADK”, con una diferencia: el modelo Gemini alojado en la nube es reemplazado por Gemma 4, que se ejecuta localmente a través de Ollama.

Elegir el modelo

Gemma 4 es una familia más reciente de modelos abiertos de Google DeepMind que cuenta con entrada multimodal, razonamiento, uso de herramientas y soporte para programación. Esta configuración utiliza:

gemma4:e4b

La etiqueta E4B se refiere al número efectivo de parámetros activos a la vez, con el objetivo de ofrecer mayor capacidad sin tener que utilizar todos los parámetros para cada entrada. La versión de Ollama ocupa aproximadamente 9,6 GB y debería funcionar en una Mac con 16 GB de memoria unificada, aunque quedarán pocos recursos para otras aplicaciones. En máquinas con limitaciones, existe una variante más pequeña:

gemma4:e2b

Se sacrifica algo de calidad en el razonamiento a cambio de velocidad y un menor consumo de memoria.

La máquina de referencia era un Apple M1 Pro con un procesador de 10 núcleos, 16 GB de memoria unificada, macOS, Python 3.13, Homebrew y Ollama. Otros sistemas compatibles con Ollama también deberían funcionar, aunque los comandos de instalación y la velocidad serán diferentes.

Paso 1: instalar Ollama

Ollama es una forma sencilla de descargar y ejecutar modelos abiertos localmente. Con Homebrew:

brew install ollama

Si ya está instalado, actualícelo:

brew update
brew upgrade ollama

Confirme la instalación:

ollama --version

La aplicación para macOS del sitio oficial de Ollama es una alternativa.

Paso 2: descargar el modelo

Descargue el modelo E4B. Espere varios minutos, ya que el archivo tiene varios gigabytes de tamaño:

ollama pull gemma4:e4b

Luego verifica que esté listado:

ollama list

La entrada debería verse más o menos así:

NAME            ID              SIZE
gemma4:e4b      ...             9.6 GB

Paso 3: hablar directamente con el modelo

Antes de agregar ADK, verifica que Gemma funcione por sí sola a través de Ollama:

ollama run gemma4:e4b

Pruebe una instrucción sencilla:

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

Cualquier respuesta sensata demuestra que el modelo local está funcionando. Sal de la sesión interactiva con:

/bye

Esta prueba permite identificar los problemas. Si el modelo falla aquí, depurar el marco del agente es inútil.

Paso 4: verificar si Ollama ya está en ejecución

Por defecto, Ollama escucha en:

http://127.0.0.1:11434

Arrancar el servidor manualmente puede generar un error:

ollama serve

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

Ese error no significa necesariamente un problema. Por lo general, indica que Ollama ya está en funcionamiento. Pruébalo realizando una solicitud al endpoint de etiquetas:

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

Un servidor en ejecución responde con JSON que enumera los modelos instalados. Para ver qué modelos están cargados actualmente:

ollama ps

Nunca se debe iniciar un segundo servidor en el mismo puerto.

Paso 5: crear el proyecto ADK

Cree una carpeta para el proyecto en el lugar que le parezca adecuado:

cd /Users/yourusername
mkdir bloggeragent
cd bloggeragent

Cree los archivos que necesita el proyecto:

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

El diseño debería quedar así:

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

Paso 6: un entorno virtual

Un entorno virtual de Python mantiene las dependencias del proyecto separadas del resto del sistema. Crea uno:

python3 -m venv .venv

Actívalo:

source .venv/bin/activate

El símbolo del sistema ahora debería comenzar con:

(.venv)

Verifique que se esté utilizando el intérprete correcto:

which python

La ruta devuelta debe apuntar al interior del entorno del proyecto, algo como:

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

Paso 7: instalar ADK con soporte para local-model

Coloque las dependencias en requirements.txt:

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

Luego instálelos:

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

La parte [extensions] es importante. Una instalación básica de ADK podría carecer de los paquetes opcionales que necesita el wrapper LiteLlm, y la aplicación podría fallar con un error de importación:

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

Si eso aparece, instale los complementos de forma explícita:

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

Las comillas impiden que shells como Zsh traten los corchetes como un patrón. Para verificar la integración:

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

El resultado esperado es:

LiteLLM connection ready

Paso 8: dirigir el proyecto a Ollama

Agregue la dirección local a .env:

OLLAMA_API_BASE=http://127.0.0.1:11434

A diferencia de la versión de Gemini alojada, la configuración local no requiere una clave de API de Google, por lo que esta variable está ausente:

GOOGLE_API_KEY

La configuración local sigue mereciendo protección, así que agregue estas entradas a .gitignore:

.env
.venv/
__pycache__/
*.pyc

Mantener .env fuera del control de versiones es una buena práctica, incluso cuando el archivo no contiene secretos en la actualidad.

Paso 9: convertir la carpeta en un paquete

Agregue una línea a __init__.py para que ADK pueda importar la definición del agente desde el paquete:

from . import agent

Paso 10: definir el modelo local

Abra agent.py y comience con las importaciones:

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

Cargar la configuración del entorno:

load_dotenv()

Cree el conector al modelo local:

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

Google recomienda el proveedor ollama_chat en lugar de ollama simple. La interfaz específica para chats mantiene mejor el contexto de la conversación y reduce la posibilidad de llamadas repetidas e inapropiadas a las herramientas. Con el modelo más pequeño, solo cambia la cadena del modelo:

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

Paso 11: el flujo de trabajo multiagente

El código completo para el sistema multiagente proviene del codelab de Google, en la sección dedicada a crear un escritor de blogs multiagente. El código proporcionado se encuentra en agent.py. Este archivo define los siguientes componentes:

• BlogPlanner genera el esquema del artículo.
• OutlineValidationChecker lo revisa.
• RobustBlogPlanner ejecuta la planificación y dicha revisión dentro de un bucle con un límite fijo.
• BlogWriter expande el esquema en el artículo completo.
• BlogPostValidationChecker examina el texto finalizado.
• RobustBlogWriter vincula el proceso de escritura con esa revisión.
• planner_tool y writer_tool presentan los dos flujos de trabajo como herramientas utilizables.
• root_agent dirige todo el proceso desde el inicio hasta el final.

En la versión original, estos agentes hablan con un modelo Gemini alojado. La arquitectura se mantiene, y solo cambia la configuración del modelo.

Al igual que en el codelab, __init__.py contiene:

from . import agent

Eso expone el flujo de trabajo del agente al ejecutor de ADK. A continuación, ajuste las importaciones en agent.py del codelab. Agregue la importación de LiteLlm:

from google.adk.models.lite_llm import LiteLlm

Estas dos importaciones no se utilizan en el código proporcionado y pueden eliminarse:

import sys
from pathlib import Path

Estos permanecen:

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

El codelab define su modelo mediante una búsqueda en el entorno:

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

Sustituya esa línea por el conector local:

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

La parte superior de agent.py debería leer lo siguiente:

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

Las definiciones del planificador, el escritor, los validadores, LoopAgent, AgentTool y root_agent permanecen exactamente como se presentan en el codelab. Cada agente ya incluye:

model=MODEL

Por lo tanto, al cambiar la variable MODEL compartida, todo el sistema se redirige desde la API Gemini alojada a Gemma 4, que se ejecuta a través de Ollama.

Qué se practica aquí

Varios conceptos relacionados con los agentes se dan en este pequeño proyecto:

• Razonamiento: Gemma interpreta el objetivo y decide cuál es el enfoque a seguir.
• Planificación: el agente planificador elabora un esquema preliminar.
• Acción: el agente principal invoca los flujos de trabajo especializados.
• Uso de herramientas: la planificación y la redacción se presentan como herramientas del agente.
• Estatuto compartido: los resultados se transmiten desde el planificador al redactor y a los verificadores.
• Validación: agentes verificadores dedicados examinan cada salida intermedia.
• Orquestación: un agente principal decide qué se ejecuta y cuándo.
• Iteración: los bucles limitados permiten realizar revisiones.
• Inferencia local: Ollama ejecuta Gemma 4 en la Mac.

Juntos demuestran un modelo de lenguaje alojado localmente que funciona como motor de razonamiento dentro de un sistema agente más amplio.

Ejecutar la versión final

Una implementación completa, con planificador, escritor, validadores, la configuración local de Gemma 4 y el agente principal, se publica en un repositorio de GitHub llamado bloggeragent. Para usarlo, clónelo:

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

Cree y active un entorno virtual:

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

Instale las dependencias:

python -m pip install -r requirements.txt

Esta es la adaptación local completa del ejemplo de escritura de blogs de Google, configurada para Gemma 4 mediante Ollama y LiteLLM en lugar de la API Gemini alojada en la nube.

Conclusión

Un agente de IA no siempre necesita una API de modelo de pago. Con Gemma 4, Ollama, LiteLLM y Google ADK, una aplicación multiagente puede planificar un artículo, validar dicho plan, redactar un borrador, revisarlo y devolver el resultado en una Mac con Apple Silicon sin costos por solicitud. Ejecutarlo localmente también facilita comprender cómo funcionan los sistemas de agentes detrás de la interfaz de chat.

La lección principal es que un agente es más que su modelo de lenguaje. Uno capaz surge de la combinación de un modelo, instrucciones, herramientas, estado, orquestación, validación y medidas de seguridad. Ejecutar el modelo localmente brinda más control sobre la infraestructura, y el diseño del sistema alrededor de él determina si ese control genera algo útil, fiable y responsable.