El function calling (o llamada a herramientas) es lo que convierte un modelo de lenguaje que solo escribe texto en algo que puede actuar: consultar el clima, buscar en una base de datos o llamar a una API, todo con un modelo que ejecutas en tu propia máquina con Ollama. En esta guía verás qué modelos de Ollama admiten herramientas, cómo es su API de tools, un ejemplo completo en Python y qué límites tiene hacerlo de forma local. La misma explicación está disponible en inglés.

Puntos clave

  • Ollama añadió soporte de herramientas el 25 de julio de 2024 y hoy va por la versión v0.32.1, publicada el 16 de julio de 2026; el proyecto supera las 176 000 estrellas en GitHub.
  • El function calling no ejecuta nada por su cuenta: el modelo devuelve el nombre de una función y sus argumentos, y es tu código quien la ejecuta y le pasa el resultado de vuelta.
  • No todos los modelos sirven. Los primeros con soporte fueron Llama 3.1, Mistral Nemo, Firefunction v2 y Command-R+; en 2026 los más fiables en tu propia máquina son qwen3, llama3.3, mistral-small3.2, gemma3 y granite4.
  • La API reutiliza el esquema de OpenAI: un array tools con objetos {type: "function", function: {...}} donde parameters es un JSON Schema. El SDK de Python te ahorra escribirlo: pasas la función directamente.
  • Los modelos pequeños que caben en tu equipo son menos fiables que las API de frontera: a veces omiten la llamada o generan argumentos mal formados, así que conviene validar siempre lo que devuelven.

¿Qué modelos de Ollama admiten herramientas?

No todos los modelos saben usar herramientas: el modelo tiene que haberse entrenado para emitir llamadas a funciones en un formato estructurado. Ollama marca cada modelo compatible con la etiqueta Tools en su catálogo, así que ese es el primer sitio donde mirar.

Cuando Ollama estrenó la función, el 25 de julio de 2024, la lista era corta: Llama 3.1, Mistral Nemo, Firefunction v2 y Command-R+. Dos años después el catálogo es mucho más amplio y, sobre todo, más fiable. Para 2026, las pruebas independientes coinciden en que qwen3 de Alibaba es el más estable en tu propia máquina, con el menor porcentaje de llamadas descartadas; le siguen llama3.3, mistral-small3.2, gemma3 (y el reciente gemma4), granite4 de IBM y gpt-oss.

La regla práctica es sencilla: cuanto más grande y menos cuantizado sea el modelo, mejor razona sobre cuándo y cómo llamar a una herramienta. Un qwen3:8b es un buen punto de partida en un portátil con GPU; si buscas la máxima fiabilidad y tienes memoria de sobra, sube a una variante de más parámetros. Descargar cualquiera de ellos es una sola orden:

ollama pull qwen3

# El cliente de Python que usaremos en los ejemplos
pip install ollama

¿Cómo funciona la API de herramientas de Ollama?

Ollama adoptó el mismo esquema que popularizó OpenAI, así que si has usado function calling en la nube te resultará familiar. En la documentación oficial lo definen así: una herramienta permite «que un modelo responda a una petición usando herramientas que conoce, lo que hace posible que los modelos realicen tareas más complejas o interactúen con el mundo exterior».

Cada herramienta se describe con tres datos: un nombre, una descripción en lenguaje natural (que el modelo lee para decidir cuándo usarla) y un esquema de parámetros en formato JSON Schema. Ese esquema es un array tools que pasas en la petición chat. El flujo tiene siempre cuatro pasos:

  1. Envías el mensaje del usuario junto con la lista de tools.
  2. Si el modelo decide usar una, no responde con texto: devuelve una o varias entradas en message.tool_calls con el nombre y los argumentos.
  3. Tu código ejecuta la función real con esos argumentos.
  4. Añades el resultado como un mensaje con role: "tool" y vuelves a llamar a chat para que el modelo redacte la respuesta final.

El punto que más confunde a quien empieza es el tercero: Ollama nunca ejecuta tu función. Solo te dice qué función quiere y con qué argumentos; la responsabilidad (y la seguridad) de ejecutarla es tuya.

¿Cómo se escribe un ejemplo en Python?

La forma cómoda es con el cliente oficial de Python, que analiza tu función automáticamente: lee la firma y el docstring y construye el JSON Schema por ti, así que no tienes que escribirlo a mano. El siguiente ejemplo define una herramienta de clima ficticia y deja que qwen3 decida cuándo llamarla:

from ollama import chat

def obtener_clima(ciudad: str) -> str:
    """Devuelve la temperatura actual de una ciudad."""
    datos = {"Madrid": "31 grados", "Londres": "18 grados"}
    return datos.get(ciudad, "sin datos")

mensajes = [{"role": "user", "content": "Que temperatura hace en Madrid?"}]

respuesta = chat(model="qwen3", messages=mensajes, tools=[obtener_clima])

# El modelo no responde con texto: pide llamar a la herramienta
for llamada in respuesta.message.tool_calls or []:
    resultado = obtener_clima(**llamada.function.arguments)
    mensajes.append(respuesta.message)
    mensajes.append({"role": "tool", "tool_name": llamada.function.name,
                     "content": resultado})

# Segunda llamada: ahora el modelo redacta la respuesta final
final = chat(model="qwen3", messages=mensajes)
print(final.message.content)

Fíjate en la doble llamada a chat: la primera obtiene la intención del modelo, ejecutas la herramienta y la segunda produce la respuesta en lenguaje natural con el dato ya incorporado. Si prefieres no depender de la introspección del SDK (por ejemplo, desde otro lenguaje), puedes pasar el JSON Schema completo en tools, con type, function.name, function.description y function.parameters.

¿Cómo llamas a una herramienta real (clima o base de datos)?

El ejemplo anterior devuelve datos inventados; en un caso real, dentro de obtener_clima harías una petición HTTP a una API meteorológica. El patrón no cambia. Y ahí está la gracia del function calling: puedes conectar el modelo a cualquier cosa que sepas expresar como una función de Python. Una consulta a una base de datos, por ejemplo, sigue el mismo molde:

def contar_pedidos(cliente_id: int) -> str:
    """Cuenta los pedidos de un cliente por su identificador."""
    fila = db.execute(
        "SELECT COUNT(*) FROM pedidos WHERE cliente_id = ?",
        (cliente_id,),
    ).fetchone()
    return f"El cliente {cliente_id} tiene {fila[0]} pedidos."

Un consejo de seguridad importante: como el modelo elige los argumentos, valida siempre lo que llega antes de tocar la base de datos. Nunca interpoles los argumentos directamente en una consulta SQL; usa parámetros (los ? del ejemplo) para evitar inyección. Este patrón (modelo local que planifica y herramientas que actúan) es la base de los agentes; si quieres orquestar varios pasos con memoria y ramificaciones, un marco como LangGraph o el flujo del SDK de agentes de Anthropic te dará estructura por encima de estas llamadas sueltas.

¿Qué límites tiene el tool calling en tu propia máquina?

Hacerlo de forma local tiene ventajas claras (privacidad, coste cero por token y sin dependencia de una nube), pero conviene ser honesto con sus límites frente a las API de frontera como GPT-4o o Claude:

  • Fiabilidad. Un modelo de 7 u 8 mil millones de parámetros a veces omite la llamada cuando debería hacerla, o genera argumentos con el nombre de campo equivocado. Los modelos grandes fallan menos, pero piden más VRAM.
  • JSON no garantizado. En modelos pequeños los argumentos pueden venir mal formados; valida siempre y prevé un reintento.
  • Sin streaming inicial. Las llamadas a herramientas y la opción de forzar una herramienta concreta (tool choice) llegaron después del estreno; comprueba que tu versión de Ollama las soporta.
  • Ventana de contexto. Muchas herramientas y resultados largos consumen contexto rápido; vigila el límite del modelo que uses.

La recomendación práctica: empieza con una o dos herramientas bien descritas, elige un modelo entrenado para ello (qwen3, llama3.3) y añade validación en tu código. Para tareas críticas o con muchas herramientas encadenadas, una API de frontera sigue siendo más robusta; para prototipos, uso personal y datos sensibles, el function calling con Ollama es una opción excelente.

Preguntas frecuentes

¿Ejecuta Ollama la función por mí?

No. Ollama (y el modelo) solo deciden qué función llamar y con qué argumentos, y te devuelven esa intención en message.tool_calls. Ejecutar la función real y devolver el resultado con un mensaje de role: "tool" es responsabilidad de tu código. Esa separación es intencionada: te da control total sobre qué se ejecuta y con qué permisos, algo clave para la seguridad.

¿Qué modelo local elijo para function calling?

En 2026, qwen3 es la apuesta más segura por su fiabilidad al emitir llamadas; llama3.3, mistral-small3.2, gemma3 y granite4 también funcionan bien. Prioriza modelos que Ollama marque con la etiqueta «Tools» y, si tu equipo lo permite, elige variantes con más parámetros: razonan mejor sobre cuándo usar cada herramienta y cometen menos errores en los argumentos.

¿Funciona con la API compatible con OpenAI?

Sí. Además del cliente propio, Ollama expone un endpoint /v1/chat/completions compatible con OpenAI que también acepta el parámetro tools. Eso te permite reutilizar bibliotecas pensadas para OpenAI (o el propio SDK de OpenAI apuntando a http://localhost:11434) sin reescribir tu código de herramientas.

Conclusión

El function calling es el puente entre un modelo que solo habla y un agente que actúa, y con Ollama puedes cruzarlo sin salir de tu propia máquina: describes tus herramientas, dejas que un modelo como qwen3 decida cuándo usarlas y tu código las ejecuta. Recuerda las dos claves: el modelo nunca ejecuta nada por su cuenta, y en tu propio equipo la fiabilidad depende mucho de qué modelo elijas. El siguiente paso es instalar Ollama, descargar qwen3, adaptar el ejemplo de Python de arriba a una herramienta tuya y, cuando quieras encadenar varios pasos, dar el salto a un marco de agentes como LangGraph.

Fuentes: [1] Anuncio de soporte de herramientas en el blog de Ollama[1], [2] Documentación oficial de tool calling[2], [3] Ollama en GitHub[3], [4] Pruebas independientes de modelos locales para tool calling, de Local AI Master[4].

Visitas: 0

Fuentes

  1. Anuncio de soporte de herramientas en el blog de Ollama
  2. Documentación oficial de tool calling
  3. Ollama en GitHub
  4. Pruebas independientes de modelos locales para tool calling, de Local AI Master

Ruta: Modelos agénticos self-hosted y tool calling