Llamadas de herramienta en Ollama: qué son y cómo usarlas desde cero

Imagina que le preguntas a tu IA local: “¿Qué temperatura hace ahora en casa?” El modelo solo sabe lo que leyó durante su entrenamiento — no puede consultar tu sensor de temperatura en tiempo real. Ahí es donde entran las llamadas de herramienta (en inglés, tool calls o function calling).

Una llamada de herramienta es una forma de decirle al modelo: “Si necesitas información externa o quieres hacer algo concreto, puedes pedirme que ejecute esta función.” El modelo no ejecuta código por sí solo — tú defines qué funciones existen, y él decide cuándo y cómo llamarlas.

Es una de las funciones más útiles de Ollama para proyectos de automatización del hogar, y en esta guía te explico cómo funciona desde cero.

Qué necesitas antes de empezar

Ollama instalado y funcionando — si no lo tienes, empieza por la guía Cómo instalar y usar Ollama
Un modelo que soporte llamadas de herramienta (la lista está abajo)
Python instalado — la mayoría de Mac y Linux ya lo traen; en Windows descárgalo en python.org
Saber copiar y ejecutar comandos en la terminal

No necesitas experiencia programando para entender el concepto. Los ejemplos son simples a propósito.

Qué modelos soportan llamadas de herramienta

No todos los modelos de Ollama tienen esta capacidad. Los que funcionan bien a día de hoy:

Modelo	Comando	Notas
`llama3.1`	`ollama pull llama3.1`	El más fiable para empezar
`llama3.2`	`ollama pull llama3.2`	Más ligero, buena alternativa
`mistral`	`ollama pull mistral`	Sólido en español
`qwen2.5`	`ollama pull qwen2.5`	Muy bueno con herramientas
`qwen2.5-coder`	`ollama pull qwen2.5-coder`	Para proyectos con código

Si tienes 8 GB de RAM: llama3.2 o qwen2.5:3b. Si tienes 16 GB o más: llama3.1 o mistral.

Para verificar que tienes el modelo descargado:

ollama list

Cómo funciona el concepto (sin código)

El flujo de una llamada de herramienta tiene tres pasos:

1. Tú describes las herramientas disponibles. Antes de hacer la pregunta, le explicas al modelo qué funciones puede pedir: cómo se llaman, qué hacen, y qué datos necesitan. Por ejemplo: “Existe una función llamada obtener_temperatura que recibe el nombre de una habitación y devuelve la temperatura actual.”

2. El modelo decide si necesita una herramienta. Cuando haces una pregunta, el modelo evalúa si puede responderla con lo que sabe, o si necesita llamar a alguna de las funciones que le describiste. Si la necesita, responde con una petición de llamada — no con texto normal.

3. Tú ejecutas la función y devuelves el resultado. Tu código ejecuta la función real (consulta un sensor, llama a una API, lee un archivo) y le envía el resultado al modelo. Él usa ese dato para generar la respuesta final.

El modelo nunca accede directamente a tu sistema. Solo pide permiso para que tu código ejecute algo. Tú controlas qué funciones existen y qué pueden hacer.

Tu primer tool call: ejemplo con curl

Abre la terminal y asegúrate de que Ollama está activo. Luego ejecuta:

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.1",
  "messages": [
    {"role": "user", "content": "¿Qué temperatura hay en el salón?"}
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "obtener_temperatura",
        "description": "Obtiene la temperatura actual de una habitación de la casa",
        "parameters": {
          "type": "object",
          "properties": {
            "habitacion": {
              "type": "string",
              "description": "Nombre de la habitación: salon, dormitorio, cocina, etc."
            }
          },
          "required": ["habitacion"]
        }
      }
    }
  ],
  "stream": false
}'

La respuesta no será texto normal — verás algo como esto:

{
  "message": {
    "role": "assistant",
    "content": "",
    "tool_calls": [
      {
        "function": {
          "name": "obtener_temperatura",
          "arguments": {"habitacion": "salon"}
        }
      }
    ]
  }
}

El modelo no inventó una temperatura. Reconoció que necesita datos externos y te pidió que ejecutes obtener_temperatura con salon como argumento. Ahora es tu código quien tiene que ejecutar esa función y devolverle el resultado.

Ejemplo práctico completo en Python

Instala la librería oficial de Ollama:

pip install ollama

Ahora crea un archivo temperatura.py con este contenido:

import ollama

# Esta es la función "real" — en un proyecto domótico consultaría
# un sensor de Home Assistant, un archivo, o una API local.
def obtener_temperatura(habitacion: str) -> str:
    temperaturas = {
        "salon": "22°C",
        "dormitorio": "19°C",
        "cocina": "24°C",
    }
    return temperaturas.get(habitacion, "Habitación no encontrada")

# Describimos las herramientas disponibles para el modelo
herramientas = [
    {
        "type": "function",
        "function": {
            "name": "obtener_temperatura",
            "description": "Obtiene la temperatura actual de una habitación",
            "parameters": {
                "type": "object",
                "properties": {
                    "habitacion": {
                        "type": "string",
                        "description": "salon, dormitorio o cocina"
                    }
                },
                "required": ["habitacion"]
            }
        }
    }
]

# Paso 1: enviamos la pregunta con las herramientas disponibles
respuesta = ollama.chat(
    model="llama3.1",
    messages=[{"role": "user", "content": "¿Está demasiado fría la cocina?"}],
    tools=herramientas
)

# Paso 2: comprobamos si el modelo quiere llamar a alguna herramienta
if respuesta.message.tool_calls:
    mensajes = [
        {"role": "user", "content": "¿Está demasiado fría la cocina?"},
        {"role": "assistant", "content": "", "tool_calls": respuesta.message.tool_calls}
    ]

    for llamada in respuesta.message.tool_calls:
        nombre = llamada.function.name
        argumentos = llamada.function.arguments

        # Paso 3: ejecutamos la función real
        if nombre == "obtener_temperatura":
            resultado = obtener_temperatura(**argumentos)
            mensajes.append({
                "role": "tool",
                "content": resultado
            })

    # Paso 4: enviamos el resultado al modelo para que responda
    respuesta_final = ollama.chat(
        model="llama3.1",
        messages=mensajes
    )
    print(respuesta_final.message.content)
else:
    # El modelo respondió directamente sin necesitar herramientas
    print(respuesta.message.content)

Ejecuta el script:

python temperatura.py

El modelo consultará la temperatura de la cocina (24°C en nuestro ejemplo) y responderá algo como: “La cocina está a 24°C, que es una temperatura bastante agradable para cocinar — no está fría en absoluto.”

Por qué esto es útil para domótica con IA local

El ejemplo de temperatura es sencillo a propósito, pero el patrón es el mismo para cosas más interesantes:

Consultar Home Assistant: Puedes definir herramientas que llamen a la API local de Home Assistant y devuelvan el estado de cualquier entidad: si una luz está encendida, qué temperatura marca el termostato, si alguien hay en casa según el sensor de presencia.

Activar dispositivos: Una herramienta puede llamar a la API de Home Assistant para encender una luz o cambiar el estado de un switch. El modelo decide cuándo hacerlo según el contexto de la conversación.

Consultar datos en tiempo real: Temperatura exterior, precio de la electricidad, el estado de tu robot aspirador — cualquier cosa que tengas en una API local puede convertirse en una herramienta.

Cadenas de decisión: El modelo puede llamar a varias herramientas en secuencia. Primero comprueba si hay alguien en casa, luego mira la temperatura, y con esa información decide si recomendar subir la calefacción.

La combinación de Ollama + herramientas locales + Home Assistant es lo que convierte un chat de IA en un asistente domótico que entiende el contexto real de tu casa.

Lo que no te van a contar

Los modelos más pequeños (los que caben en 8 GB de RAM) a veces se equivocan en la llamada: llaman a la herramienta incorrecta, pasan argumentos con nombres distintos a los definidos, o directamente ignoran las herramientas y responden de memoria. llama3.1 y qwen2.5 son los más fiables, pero no son perfectos.

Las llamadas de herramienta funcionan mejor con descripciones claras. Si la descripción de la función es vaga, el modelo puede no entender cuándo usarla. Vale la pena ser explícito: “Esta función devuelve el estado actual de una luz de la casa. Úsala cuando el usuario pregunte por el estado de la iluminación.”

Si tu proyecto depende de que el modelo ejecute herramientas de forma fiable (controlar dispositivos críticos, tomar decisiones que tienen consecuencias físicas), añade siempre una capa de validación en tu código antes de actuar sobre el resultado. No confíes a ciegas en los argumentos que pasa el modelo.

Veredicto

Las llamadas de herramienta son el salto entre “chatear con la IA” y “la IA que hace cosas útiles en tu casa”. No son complicadas de implementar — el patrón es siempre el mismo: describes la función, el modelo decide cuándo llamarla, tú la ejecutas y le devuelves el resultado.

Para un primer proyecto domótico con Ollama, el camino más natural es: instalar Ollama → conectarlo a Home Assistant mediante su API local → definir herramientas que lean y escriban estados. Con eso, ya tienes un asistente de voz que entiende el contexto real de tu casa sin depender del cloud.