Funciones en Ollama (Function Calling)

Qué cubre este artículo

• Qué es Function Calling.
• Cómo definir herramientas en Ollama.
• Modo JSON y force-output.
• Qué modelos soportan funciones.
• Ejemplo práctico en Python.

Introducción: Funciones en Ollama (Function Calling)

Function Calling permite que los modelos de lenguaje desencadenen acciones devolviendo parámetros estructurados para funciones externas. En lugar de formular la respuesta directamente, el modelo invoca una función herramienta, por ejemplo para consultar el clima, realizar un cálculo o buscar datos. En Ollama, Function Calling está disponible de forma limitada y normalmente requiere salida JSON y un modelo que entienda herramientas.

Este artículo explica cómo funciona Function Calling con Ollama.

Conceptos clave

• Function Calling: El modelo invoca funciones externas.
• Tool: Función externa conocida por el modelo.
• Schema: Esquema JSON para los parámetros de la función.
• JSON-Modus: Fuerza salida JSON válida.
• force: Obliga al modelo a invocar una función específica.
• OpenAI Tools: Estándar de la industria para Function Calling.
• Ollama tools: Implementación específica de Ollama.
• Stop/Start: Caracteres de control para JSON.

Soporte en Ollama

Function Calling en Ollama es relativamente nuevo y menos completo que en OpenAI. Algunos modelos como Qwen 2.5, Llama 3.1 y ciertas variantes de Mistral pueden usar herramientas. La API sigue el formato de herramientas de OpenAI.

Definir una herramienta

{
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Devuelve el clima actual para una ubicación.",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "Ciudad o lugar"
            },
            "unit": {
              "type": "string",
              "enum": ["celsius", "fahrenheit"]
            }
          },
          "required": ["location"]
        }
      }
    }
  ]
}

Ejemplo en Python

import requests

url = "http://localhost:11434/api/chat"
payload = {
    "model": "qwen2.5:7b",
    "messages": [
        {"role": "user", "content": "¿Cuál es el clima en Berlín?"}
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Devuelve el clima actual.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {"type": "string"},
                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                    },
                    "required": ["location"]
                }
            }
        }
    ],
    "stream": False
}

response = requests.post(url, json=payload)
print(response.json())

Evaluar el resultado

El modelo responde con una estructura tool_calls:

{
  "message": {
    "role": "assistant",
    "tool_calls": [
      {
        "function": {
          "name": "get_weather",
          "arguments": {"location": "Berlín", "unit": "celsius"}
        }
      }
    ]
  }
}

Ejecutar la función

La aplicación ejecuta la función y añade el resultado al historial de conversación:

tool_result = get_weather("Berlín", "celsius")

payload["messages"].append({
    "role": "tool",
    "content": tool_result,
    "name": "get_weather"
})

response = requests.post(url, json=payload)
print(response.json()["message"]["content"])

Forzar modo JSON

{
  "format": "json"
}

Esto ayuda si el modelo envuelve el output JSON en bloques Markdown.

Modelfile de Ollama con herramientas

FROM qwen2.5:7b

PARAMETER temperature 0.1
SYSTEM "Eres un asistente que utiliza herramientas para completar tareas."

No todos los parámetros definen herramientas directamente, se pasan a través de la API.

Consejos

• Elige un modelo que soporte herramientas.
• Mantén los esquemas claros y simples.
• Usa nombres descriptivos para las herramientas.
• Valida siempre las respuestas.
• Maneja errores si el modelo alucina.
• Usa pocas herramientas por solicitud.
• Define los tipos de parámetros explícitamente.

Errores comunes

• El modelo no soporta herramientas: Los modelos pequeños o antiguos ignoran las herramientas.
• Sin salida de herramienta: El modelo responde normalmente en lugar de invocar.
• Errores JSON: El output debe poder parsearse.
• Parámetros incorrectos: El esquema es demasiado complejo.
• Múltiples invocaciones: La aplicación debe procesar varios llamados.
• CORS/Red: El cliente no puede alcanzar la API.

Enlaces y recursos adicionales

• Galería de modelos Ollama en BotServ.de
• Solución de problemas de API de Ollama en BotServ.de
• Ollama en Docker en BotServ.de
• Frameworks de IA Agentes en BotServ.de

Preguntas frecuentes: Funciones en Ollama

¿Qué modelos soportan Function Calling? Qwen 2.5, Llama 3.1 y algunas variantes de Mistral.

¿Debo definir herramientas en el Modelfile? No, se pasan a través de la API.

¿Puedo usar múltiples herramientas simultáneamente? Sí, dependiendo del modelo y la solicitud.

¿Cómo fuerzo salida JSON? Con "format": "json".

¿Funciona Function Calling en todos los modelos? No, solo en aquellos entrenados para esto.

Fuentes y lecturas adicionales

• Ollama Tools: https://ollama.com/blog/tool-support
• Function Calling de OpenAI: https://platform.openai.com/docs/guides/function-calling

Resumen: Funciones en Ollama (Function Calling)

Function Calling permite que los modelos de Ollama invoquen herramientas externas. Las herramientas se definen como esquemas JSON y se pasan a través de la API. Modelos como Qwen 2.5 y Llama 3.1 soportan este modo. La aplicación debe recibir las invocaciones de herramientas, ejecutar las funciones y devolver los resultados. Con esquemas claros, salida JSON y validación, es posible implementar flujos de agentes incluso de forma local.