Gemma 4 y tool calling: cómo crear agentes IA locales con Ollama

Introducción

La capacidad de que un modelo de lenguaje invoque funciones reales —tool calling— transforma qué puede hacer una IA: en lugar de inventar datos cuando se le pide información actualizada, el modelo identifica la herramienta correcta, arma la llamada con sus argumentos y espera el resultado que la función retorne. Con Gemma 4 (Edge) y Ollama pueden construirse agentes que ejecutan esas funciones localmente, acceden a APIs reales y operan sin depender de servicios en la nube.

Este enfoque es especialmente relevante para organizaciones en América Latina que buscan reducir costos, mantener control sobre datos sensibles y desplegar agentes en entornos con conectividad limitada.

¿Qué es tool calling en modelos de lenguaje?

Tool calling permite que el modelo reconozca cuándo necesita información externa, seleccione la función adecuada y genere una llamada con los parámetros correctos. Importante: el modelo no ejecuta el código; solo decide qué función llamar y cómo estructurar los argumentos. El código del usuario es el que realmente ejecutará la función y devolverá el resultado al modelo.

Este patrón de dos pasos (modelo -> llamada a herramienta -> ejecución por el código del usuario -> respuesta como “role: ‘tool’” al modelo) es la base de los agentes que hacen tareas en tiempo real, como obtener precios, clima o consultar bases de datos.

Arquitectura de tool calling con Gemma 4 y Ollama

El flujo típico es:

1. Definir funciones en Python que realizan tareas concretas (consultar APIs externas, transformar datos, consultar una base local).
2. Crear un esquema JSON para cada función que describa su nombre y parámetros (tipos y propósito).
3. Enviar al endpoint de Ollama tanto el mensaje del sistema como los esquemas de las herramientas.
4. Ollama responde con un bloque tool_calls en lugar de texto plano cuando el modelo decide invocar una herramienta.
5. Ejecutar la función localmente usando los parámetros provistos por Ollama.
6. Devolver el resultado a Ollama con una respuesta de rol “tool”.
7. Ollama integra esa salida y compone la respuesta final en lenguaje natural.

Ese ciclo permite que el modelo actúe como “cerebro” mientras que las funciones son las “manos” que interactúan con el mundo real.

Preparación del entorno: instalar Ollama y descargar Gemma 4 Edge

Para correr estos agentes localmente necesitarán Ollama y el modelo Gemma 4 Edge 2B. No hacen falta dependencias externas más allá de la instalación estándar de Python.

Comandos principales (macOS / Linux):

# Instalar Ollama
curl --fail -fsSL https://ollama.com/install.sh | sh

# Descargar el modelo Gemma 4 Edge (aprox. 2.5 GB)
ollama pull gemma4:e2b

# Verificar modelos disponibles
ollama list

Después de descargar el modelo, Ollama expone una API local en http://localhost:11434 a la que podemos enviar solicitudes.

Conexión mínima: helper para llamar a Ollama

Un pequeño helper en Python permite enviar la carga útil al endpoint local sin bibliotecas adicionales:

import json, urllib.request, urllib.parse

def call_ollama(payload: dict) -> dict:
    data = json.dumps(payload).encode("utf-8")
    req = urllib.request.Request(
        "http://localhost:11434/api/chat",
        data=data,
        headers={"Content-Type": "application/json"},
    )
    with urllib.request.urlopen(req) as resp:
        return json.loads(resp.read().decode("utf-8"))

No se requieren paquetes externos, lo que facilita despliegues en entornos controlados.

Tarea práctica 1: consulta de clima en vivo

Un ejemplo directo es usar una API pública gratuita para obtener clima en tiempo real a partir de coordenadas. El patrón es:

1. Crear una función en Python que, dados parámetros (por ejemplo nombre de ciudad y unidad), haga las llamadas HTTP necesarias para obtener geolocalización y luego el clima actual.
2. Definir un esquema JSON que describa esa función para que Gemma 4 sepa cuándo y cómo invocarla.
3. Enviar ese esquema a Ollama junto con el prompt; si el modelo decide llamar la función, Ollama retornará en tool_calls los parámetros a ejecutar.

Ejemplo de función (simplificada):

def get_current_weather(city: str, unit: str = "celsius") -> str:
    geo_url = f"https://geocoding-api.open-meteo.com/v1/search?name={urllib.parse.quote(city)}&count=1"
    with urllib.request.urlopen(geo_url) as r:
        geo = json.loads(r.read())
        loc = geo["results"][0]
        lat, lon = loc["latitude"], loc["longitude"]
    url = (
        f"https://api.open-meteo.com/v1/forecast"
        f"?latitude={lat}&longitude={lon}"
        f"&current=temperature_2m,wind_speed_10m"
        f"&temperature_unit={unit}"
    )
    with urllib.request.urlopen(url) as r:
        data = json.loads(r.read())
        c = data["current"]
    return f"{city}: {c['temperature_2m']}°, wind {c['wind_speed_10m']} km/h"

Este ejemplo utiliza servicios públicos de Open-Meteo que no requieren clave, y demuestra cómo el agente puede devolver una respuesta precisa basada en datos en tiempo real.

Tarea práctica 2: convertidor de moneda en vivo (patrón)

Aunque no vamos a incluir código específico de una API en este artículo, la idea es la misma que en el ejemplo del clima:

• Definan una función que consulte un servicio de tasas de cambio (o una fuente local de precios) y normalice el resultado.
• Describan su esquema JSON con parámetros como moneda origen, destino y monto.
• Dejen que Gemma 4 elija invocar esa herramienta cuando el usuario solicite una conversión.

Este enfoque es útil para empresas latinoamericanas que quieran ofrecer conversiones actualizadas en apps locales sin exponer datos a la nube.

Tarea práctica 3: agente multi-herramienta (llamadas encadenadas)

Los agentes pueden encadenar herramientas: por ejemplo, primero obtener geolocalización, luego consultar el clima y después guardar un registro en una base de datos local. El patrón sigue siendo el mismo:

1. Proveer varios esquemas de funciones a Ollama.
2. Permitir que Gemma 4 decida qué función invocar en cada paso.
3. Tras cada ejecución, retornar el resultado con rol “tool” para que el modelo continúe la conversación o tome la siguiente decisión.

Este tipo de agentes “stacked calls” permite flujos complejos sin salir del entorno controlado, ideal para automatizaciones en puntos de venta, logística o soporte técnico.

¿Qué hace diferente a Gemma 4 para agentes?

Gemma 4 Edge ofrece tool calling integrado, lo que facilita construir agentes locales y deterministas. Combinado con Ollama, se obtiene un stack que puede correr completamente offline o en infraestructuras propias, reduciendo dependencia de suscripciones y mejorando la privacidad.

Conclusión y consideraciones para Latinoamérica

Tool calling con Gemma 4 y Ollama permite crear agentes IA prácticos, auditables y desplegables en entornos con restricciones de datos o presupuesto. Para equipos en América Latina esto se traduce en ventajas operativas: control sobre la información, menor exposición a costos de nube y la posibilidad de ejecutar capacidades avanzadas en el edge.

Antes de desplegar en producción, consideren:

• Diseñar esquemas y validaciones robustas para las funciones que expondrán al modelo.
• Controlar permisos y accesos a APIs externas y a datos sensibles.
• Monitorear las ejecuciones de las funciones para detectar errores y respuestas inesperadas.

Con la arquitectura descrita podrán prototipar agentes que respondan con datos reales y, al mismo tiempo, mantener el control operativo y económico que muchas organizaciones en la región necesitan.